diff --git a/api/specs.pb.go b/api/specs.pb.go
index a789d5a95e..830a41039e 100644
--- a/api/specs.pb.go
+++ b/api/specs.pb.go
@@ -5,14 +5,13 @@ package api
 
 import (
 	fmt "fmt"
+	github_com_docker_swarmkit_api_deepcopy "github.com/docker/swarmkit/api/deepcopy"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
 	types "github.com/gogo/protobuf/types"
-	github_com_moby_swarmkit_v2_api_deepcopy "github.com/moby/swarmkit/v2/api/deepcopy"
 	io "io"
 	math "math"
-	math_bits "math/bits"
 	reflect "reflect"
 	strings "strings"
 )
@@ -26,7 +25,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
 
 type NodeSpec_Membership int32
 
@@ -155,40 +154,6 @@ func (EndpointSpec_ResolutionMode) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_6589acc608f7d4fd, []int{11, 0}
 }
 
-type VolumeSpec_VolumeAvailability int32
-
-const (
-	// Active allows a volume to be used and scheduled to. This is the
-	// default state.
-	VolumeAvailabilityActive VolumeSpec_VolumeAvailability = 0
-	// Pause prevents volumes from having new workloads scheduled to use
-	// them, even if they're already published on a Node.
-	VolumeAvailabilityPause VolumeSpec_VolumeAvailability = 1
-	// Drain causes existing workloads using this volume to be rescheduled,
-	// causing the volume to be unpublished and removed from nodes.
-	VolumeAvailabilityDrain VolumeSpec_VolumeAvailability = 2
-)
-
-var VolumeSpec_VolumeAvailability_name = map[int32]string{
-	0: "ACTIVE",
-	1: "PAUSE",
-	2: "DRAIN",
-}
-
-var VolumeSpec_VolumeAvailability_value = map[string]int32{
-	"ACTIVE": 0,
-	"PAUSE":  1,
-	"DRAIN":  2,
-}
-
-func (x VolumeSpec_VolumeAvailability) String() string {
-	return proto.EnumName(VolumeSpec_VolumeAvailability_name, int32(x))
-}
-
-func (VolumeSpec_VolumeAvailability) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_6589acc608f7d4fd, []int{16, 0}
-}
-
 type NodeSpec struct {
 	Annotations Annotations `protobuf:"bytes,1,opt,name=annotations,proto3" json:"annotations"`
 	// DesiredRole defines the role the node should have.
@@ -213,7 +178,7 @@ func (m *NodeSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_NodeSpec.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -276,7 +241,7 @@ func (m *ServiceSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_ServiceSpec.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -302,16 +267,16 @@ type isServiceSpec_Mode interface {
 }
 
 type ServiceSpec_Replicated struct {
-	Replicated *ReplicatedService `protobuf:"bytes,3,opt,name=replicated,proto3,oneof" json:"replicated,omitempty"`
+	Replicated *ReplicatedService `protobuf:"bytes,3,opt,name=replicated,proto3,oneof"`
 }
 type ServiceSpec_Global struct {
-	Global *GlobalService `protobuf:"bytes,4,opt,name=global,proto3,oneof" json:"global,omitempty"`
+	Global *GlobalService `protobuf:"bytes,4,opt,name=global,proto3,oneof"`
 }
 type ServiceSpec_ReplicatedJob struct {
-	ReplicatedJob *ReplicatedJob `protobuf:"bytes,10,opt,name=replicated_job,json=replicatedJob,proto3,oneof" json:"replicated_job,omitempty"`
+	ReplicatedJob *ReplicatedJob `protobuf:"bytes,10,opt,name=replicated_job,json=replicatedJob,proto3,oneof"`
 }
 type ServiceSpec_GlobalJob struct {
-	GlobalJob *GlobalJob `protobuf:"bytes,11,opt,name=global_job,json=globalJob,proto3,oneof" json:"global_job,omitempty"`
+	GlobalJob *GlobalJob `protobuf:"bytes,11,opt,name=global_job,json=globalJob,proto3,oneof"`
 }
 
 func (*ServiceSpec_Replicated) isServiceSpec_Mode()    {}
@@ -354,9 +319,9 @@ func (m *ServiceSpec) GetGlobalJob() *GlobalJob {
 	return nil
 }
 
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*ServiceSpec) XXX_OneofWrappers() []interface{} {
-	return []interface{}{
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*ServiceSpec) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _ServiceSpec_OneofMarshaler, _ServiceSpec_OneofUnmarshaler, _ServiceSpec_OneofSizer, []interface{}{
 		(*ServiceSpec_Replicated)(nil),
 		(*ServiceSpec_Global)(nil),
 		(*ServiceSpec_ReplicatedJob)(nil),
@@ -364,6 +329,108 @@ func (*ServiceSpec) XXX_OneofWrappers() []interface{} {
 	}
 }
 
+func _ServiceSpec_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*ServiceSpec)
+	// mode
+	switch x := m.Mode.(type) {
+	case *ServiceSpec_Replicated:
+		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Replicated); err != nil {
+			return err
+		}
+	case *ServiceSpec_Global:
+		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Global); err != nil {
+			return err
+		}
+	case *ServiceSpec_ReplicatedJob:
+		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.ReplicatedJob); err != nil {
+			return err
+		}
+	case *ServiceSpec_GlobalJob:
+		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.GlobalJob); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("ServiceSpec.Mode has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _ServiceSpec_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*ServiceSpec)
+	switch tag {
+	case 3: // mode.replicated
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(ReplicatedService)
+		err := b.DecodeMessage(msg)
+		m.Mode = &ServiceSpec_Replicated{msg}
+		return true, err
+	case 4: // mode.global
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(GlobalService)
+		err := b.DecodeMessage(msg)
+		m.Mode = &ServiceSpec_Global{msg}
+		return true, err
+	case 10: // mode.replicated_job
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(ReplicatedJob)
+		err := b.DecodeMessage(msg)
+		m.Mode = &ServiceSpec_ReplicatedJob{msg}
+		return true, err
+	case 11: // mode.global_job
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(GlobalJob)
+		err := b.DecodeMessage(msg)
+		m.Mode = &ServiceSpec_GlobalJob{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _ServiceSpec_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*ServiceSpec)
+	// mode
+	switch x := m.Mode.(type) {
+	case *ServiceSpec_Replicated:
+		s := proto.Size(x.Replicated)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *ServiceSpec_Global:
+		s := proto.Size(x.Global)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *ServiceSpec_ReplicatedJob:
+		s := proto.Size(x.ReplicatedJob)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *ServiceSpec_GlobalJob:
+		s := proto.Size(x.GlobalJob)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
 // ReplicatedService sets the reconciliation target to certain number of replicas.
 type ReplicatedService struct {
 	Replicas uint64 `protobuf:"varint,1,opt,name=replicas,proto3" json:"replicas,omitempty"`
@@ -382,7 +449,7 @@ func (m *ReplicatedService) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_ReplicatedService.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -418,7 +485,7 @@ func (m *GlobalService) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return xxx_messageInfo_GlobalService.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -463,7 +530,7 @@ func (m *ReplicatedJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return xxx_messageInfo_ReplicatedJob.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -500,7 +567,7 @@ func (m *GlobalJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_GlobalJob.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -567,7 +634,7 @@ func (m *TaskSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_TaskSpec.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -593,13 +660,13 @@ type isTaskSpec_Runtime interface {
 }
 
 type TaskSpec_Attachment struct {
-	Attachment *NetworkAttachmentSpec `protobuf:"bytes,8,opt,name=attachment,proto3,oneof" json:"attachment,omitempty"`
+	Attachment *NetworkAttachmentSpec `protobuf:"bytes,8,opt,name=attachment,proto3,oneof"`
 }
 type TaskSpec_Container struct {
-	Container *ContainerSpec `protobuf:"bytes,1,opt,name=container,proto3,oneof" json:"container,omitempty"`
+	Container *ContainerSpec `protobuf:"bytes,1,opt,name=container,proto3,oneof"`
 }
 type TaskSpec_Generic struct {
-	Generic *GenericRuntimeSpec `protobuf:"bytes,10,opt,name=generic,proto3,oneof" json:"generic,omitempty"`
+	Generic *GenericRuntimeSpec `protobuf:"bytes,10,opt,name=generic,proto3,oneof"`
 }
 
 func (*TaskSpec_Attachment) isTaskSpec_Runtime() {}
@@ -634,15 +701,99 @@ func (m *TaskSpec) GetGeneric() *GenericRuntimeSpec {
 	return nil
 }
 
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*TaskSpec) XXX_OneofWrappers() []interface{} {
-	return []interface{}{
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*TaskSpec) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _TaskSpec_OneofMarshaler, _TaskSpec_OneofUnmarshaler, _TaskSpec_OneofSizer, []interface{}{
 		(*TaskSpec_Attachment)(nil),
 		(*TaskSpec_Container)(nil),
 		(*TaskSpec_Generic)(nil),
 	}
 }
 
+func _TaskSpec_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*TaskSpec)
+	// runtime
+	switch x := m.Runtime.(type) {
+	case *TaskSpec_Attachment:
+		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Attachment); err != nil {
+			return err
+		}
+	case *TaskSpec_Container:
+		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Container); err != nil {
+			return err
+		}
+	case *TaskSpec_Generic:
+		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Generic); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("TaskSpec.Runtime has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _TaskSpec_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*TaskSpec)
+	switch tag {
+	case 8: // runtime.attachment
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(NetworkAttachmentSpec)
+		err := b.DecodeMessage(msg)
+		m.Runtime = &TaskSpec_Attachment{msg}
+		return true, err
+	case 1: // runtime.container
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(ContainerSpec)
+		err := b.DecodeMessage(msg)
+		m.Runtime = &TaskSpec_Container{msg}
+		return true, err
+	case 10: // runtime.generic
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(GenericRuntimeSpec)
+		err := b.DecodeMessage(msg)
+		m.Runtime = &TaskSpec_Generic{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _TaskSpec_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*TaskSpec)
+	// runtime
+	switch x := m.Runtime.(type) {
+	case *TaskSpec_Attachment:
+		s := proto.Size(x.Attachment)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *TaskSpec_Container:
+		s := proto.Size(x.Container)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *TaskSpec_Generic:
+		s := proto.Size(x.Generic)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
 type ResourceReference struct {
 	ResourceID   string       `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
 	ResourceType ResourceType `protobuf:"varint,2,opt,name=resource_type,json=resourceType,proto3,enum=docker.swarmkit.v1.ResourceType" json:"resource_type,omitempty"`
@@ -661,7 +812,7 @@ func (m *ResourceReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return xxx_messageInfo_ResourceReference.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -698,7 +849,7 @@ func (m *GenericRuntimeSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return xxx_messageInfo_GenericRuntimeSpec.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -738,7 +889,7 @@ func (m *NetworkAttachmentSpec) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return xxx_messageInfo_NetworkAttachmentSpec.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -874,7 +1025,8 @@ type ContainerSpec struct {
 	CapabilityDrop []string `protobuf:"bytes,28,rep,name=capability_drop,json=capabilityDrop,proto3" json:"capability_drop,omitempty"`
 	// Ulimits defines the list of ulimits to set in the container. This option
 	// is equivalent to passing --ulimit to docker run.
-	Ulimits []*ContainerSpec_Ulimit `protobuf:"bytes,29,rep,name=ulimits,proto3" json:"ulimits,omitempty"`
+	Ulimits    []*ContainerSpec_Ulimit `protobuf:"bytes,29,rep,name=ulimits,proto3" json:"ulimits,omitempty"`
+	Privileged bool                    `protobuf:"varint,30,opt,name=privileged,proto3" json:"privileged,omitempty"`
 }
 
 func (m *ContainerSpec) Reset()      { *m = ContainerSpec{} }
@@ -890,7 +1042,7 @@ func (m *ContainerSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return xxx_messageInfo_ContainerSpec.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -931,7 +1083,7 @@ func (m *ContainerSpec_PullOptions) XXX_Marshal(b []byte, deterministic bool) ([
 		return xxx_messageInfo_ContainerSpec_PullOptions.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -976,7 +1128,7 @@ func (m *ContainerSpec_DNSConfig) XXX_Marshal(b []byte, deterministic bool) ([]b
 		return xxx_messageInfo_ContainerSpec_DNSConfig.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -1014,7 +1166,7 @@ func (m *ContainerSpec_Ulimit) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return xxx_messageInfo_ContainerSpec_Ulimit.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -1055,7 +1207,7 @@ func (m *EndpointSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_EndpointSpec.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -1118,7 +1270,7 @@ func (m *NetworkSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_NetworkSpec.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -1144,7 +1296,7 @@ type isNetworkSpec_ConfigFrom interface {
 }
 
 type NetworkSpec_Network struct {
-	Network string `protobuf:"bytes,8,opt,name=network,proto3,oneof" json:"network,omitempty"`
+	Network string `protobuf:"bytes,8,opt,name=network,proto3,oneof"`
 }
 
 func (*NetworkSpec_Network) isNetworkSpec_ConfigFrom() {}
@@ -1163,13 +1315,57 @@ func (m *NetworkSpec) GetNetwork() string {
 	return ""
 }
 
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*NetworkSpec) XXX_OneofWrappers() []interface{} {
-	return []interface{}{
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*NetworkSpec) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _NetworkSpec_OneofMarshaler, _NetworkSpec_OneofUnmarshaler, _NetworkSpec_OneofSizer, []interface{}{
 		(*NetworkSpec_Network)(nil),
 	}
 }
 
+func _NetworkSpec_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*NetworkSpec)
+	// config_from
+	switch x := m.ConfigFrom.(type) {
+	case *NetworkSpec_Network:
+		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
+		_ = b.EncodeStringBytes(x.Network)
+	case nil:
+	default:
+		return fmt.Errorf("NetworkSpec.ConfigFrom has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _NetworkSpec_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*NetworkSpec)
+	switch tag {
+	case 8: // config_from.network
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.ConfigFrom = &NetworkSpec_Network{x}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _NetworkSpec_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*NetworkSpec)
+	// config_from
+	switch x := m.ConfigFrom.(type) {
+	case *NetworkSpec_Network:
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.Network)))
+		n += len(x.Network)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
 // ClusterSpec specifies global cluster settings.
 type ClusterSpec struct {
 	Annotations Annotations `protobuf:"bytes,1,opt,name=annotations,proto3" json:"annotations"`
@@ -1204,7 +1400,7 @@ func (m *ClusterSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return xxx_messageInfo_ClusterSpec.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -1251,7 +1447,7 @@ func (m *SecretSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_SecretSpec.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -1298,7 +1494,7 @@ func (m *ConfigSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return xxx_messageInfo_ConfigSpec.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
+		n, err := m.MarshalTo(b)
 		if err != nil {
 			return nil, err
 		}
@@ -1317,89 +1513,11 @@ func (m *ConfigSpec) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ConfigSpec proto.InternalMessageInfo
 
-type VolumeSpec struct {
-	// Annotations includes the name and labels of a volume. The name used in the
-	// spec's Annotations will be passed to the Plugin as the "Name" in the
-	// CreateVolume request.
-	Annotations Annotations `protobuf:"bytes,1,opt,name=annotations,proto3" json:"annotations"`
-	// Group defines the volume group this particular volume belongs to. When
-	// requesting volumes for a workload, the group name can be used instead of
-	// the volume's name, which tells swarmkit to pick one from the many volumes
-	// belonging to that group.
-	Group string `protobuf:"bytes,2,opt,name=group,proto3" json:"group,omitempty"`
-	// Driver represents the CSI Plugin object and its configuration parameters.
-	// The "options" field of the Driver object is passed in the CSI
-	// CreateVolumeRequest as the "parameters" field. The Driver must be
-	// specified; there is no default CSI Plugin.
-	Driver *Driver `protobuf:"bytes,3,opt,name=driver,proto3" json:"driver,omitempty"`
-	// AccessMode is similar to, and used to determine, the volume access mode as
-	// defined in the CSI spec, as well as the volume type (block vs mount). In
-	// this way, it is more similar to the VolumeCapability message in the CSI
-	// spec.
-	AccessMode *VolumeAccessMode `protobuf:"bytes,4,opt,name=access_mode,json=accessMode,proto3" json:"access_mode,omitempty"`
-	// Secrets represents a set of key/value pairs to pass to the CSI plugin. The
-	// keys of the secrets can be anything, but the values refer to swarmkit
-	// Secret objects. See the "Secrets Requirements" section of the CSI Plugin
-	// Spec for more information.
-	Secrets []*VolumeSecret `protobuf:"bytes,5,rep,name=secrets,proto3" json:"secrets,omitempty"`
-	// AccessibilityRequirements specifies where a volume must be accessible
-	// from.
-	//
-	// This field must be empty if the plugin does not support
-	// VOLUME_ACCESSIBILITY_CONSTRAINTS capabilities. If it is present but the
-	// plugin does not support it, volume will not be created.
-	//
-	// If AccessibilityRequirements is empty, but the plugin does support
-	// VOLUME_ACCESSIBILITY_CONSTRAINTS, then Swarmkit will assume the entire
-	// cluster is a valid target for the volume.
-	AccessibilityRequirements *TopologyRequirement `protobuf:"bytes,6,opt,name=AccessibilityRequirements,proto3" json:"AccessibilityRequirements,omitempty"`
-	// CapacityRange is the capacity this volume should be created with. If nil,
-	// the plugin will decide the capacity.
-	CapacityRange *CapacityRange `protobuf:"bytes,7,opt,name=capacity_range,json=capacityRange,proto3" json:"capacity_range,omitempty"`
-	// Availability is the Volume's desired availability. Analogous to Node
-	// Availability, this allows the user to take volumes offline in order to
-	// update or delete them.
-	Availability VolumeSpec_VolumeAvailability `protobuf:"varint,8,opt,name=availability,proto3,enum=docker.swarmkit.v1.VolumeSpec_VolumeAvailability" json:"availability,omitempty"`
-}
-
-func (m *VolumeSpec) Reset()      { *m = VolumeSpec{} }
-func (*VolumeSpec) ProtoMessage() {}
-func (*VolumeSpec) Descriptor() ([]byte, []int) {
-	return fileDescriptor_6589acc608f7d4fd, []int{16}
-}
-func (m *VolumeSpec) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *VolumeSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_VolumeSpec.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *VolumeSpec) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_VolumeSpec.Merge(m, src)
-}
-func (m *VolumeSpec) XXX_Size() int {
-	return m.Size()
-}
-func (m *VolumeSpec) XXX_DiscardUnknown() {
-	xxx_messageInfo_VolumeSpec.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_VolumeSpec proto.InternalMessageInfo
-
 func init() {
 	proto.RegisterEnum("docker.swarmkit.v1.NodeSpec_Membership", NodeSpec_Membership_name, NodeSpec_Membership_value)
 	proto.RegisterEnum("docker.swarmkit.v1.NodeSpec_Availability", NodeSpec_Availability_name, NodeSpec_Availability_value)
 	proto.RegisterEnum("docker.swarmkit.v1.ContainerSpec_Isolation", ContainerSpec_Isolation_name, ContainerSpec_Isolation_value)
 	proto.RegisterEnum("docker.swarmkit.v1.EndpointSpec_ResolutionMode", EndpointSpec_ResolutionMode_name, EndpointSpec_ResolutionMode_value)
-	proto.RegisterEnum("docker.swarmkit.v1.VolumeSpec_VolumeAvailability", VolumeSpec_VolumeAvailability_name, VolumeSpec_VolumeAvailability_value)
 	proto.RegisterType((*NodeSpec)(nil), "docker.swarmkit.v1.NodeSpec")
 	proto.RegisterType((*ServiceSpec)(nil), "docker.swarmkit.v1.ServiceSpec")
 	proto.RegisterType((*ReplicatedService)(nil), "docker.swarmkit.v1.ReplicatedService")
@@ -1421,7 +1539,6 @@ func init() {
 	proto.RegisterType((*ClusterSpec)(nil), "docker.swarmkit.v1.ClusterSpec")
 	proto.RegisterType((*SecretSpec)(nil), "docker.swarmkit.v1.SecretSpec")
 	proto.RegisterType((*ConfigSpec)(nil), "docker.swarmkit.v1.ConfigSpec")
-	proto.RegisterType((*VolumeSpec)(nil), "docker.swarmkit.v1.VolumeSpec")
 }
 
 func init() {
@@ -1429,166 +1546,156 @@ func init() {
 }
 
 var fileDescriptor_6589acc608f7d4fd = []byte{
-	// 2537 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0x41, 0x73, 0x1b, 0xb7,
-	0x15, 0x26, 0x25, 0x8a, 0x22, 0xdf, 0x92, 0x32, 0x8d, 0x38, 0xc9, 0x8a, 0xb6, 0x29, 0x86, 0x71,
-	0x1c, 0x25, 0x99, 0x52, 0x13, 0x35, 0x93, 0x26, 0x4e, 0xd3, 0x96, 0x14, 0x19, 0x8b, 0xb1, 0x2d,
-	0x73, 0x40, 0x59, 0xad, 0x67, 0x3a, 0xc3, 0x81, 0x76, 0x21, 0x72, 0xab, 0xe5, 0x62, 0x8b, 0x05,
-	0x95, 0xf0, 0xd6, 0x63, 0xc6, 0xbd, 0xf4, 0xd0, 0xab, 0x4e, 0x9d, 0x9e, 0x7a, 0x69, 0xff, 0x41,
-	0x7b, 0xcb, 0x31, 0xc7, 0xf4, 0xa2, 0x69, 0x94, 0x9f, 0xd0, 0x5b, 0x2f, 0xed, 0x00, 0x8b, 0x5d,
-	0x2e, 0x25, 0xd2, 0x72, 0xa7, 0x3e, 0xf4, 0x06, 0x3c, 0x7e, 0xdf, 0x5b, 0xe0, 0xe1, 0xbd, 0x87,
-	0xf7, 0x40, 0x78, 0x77, 0xe0, 0x88, 0xe1, 0xf8, 0xb0, 0x6e, 0xb1, 0xd1, 0x96, 0xcd, 0xac, 0x63,
-	0xca, 0xb7, 0x82, 0x2f, 0x08, 0x1f, 0x1d, 0x3b, 0x62, 0x8b, 0xf8, 0xce, 0x56, 0xe0, 0x53, 0x2b,
-	0xa8, 0xfb, 0x9c, 0x09, 0x86, 0x50, 0x08, 0xa8, 0x47, 0x80, 0xfa, 0xc9, 0xfb, 0xe5, 0xab, 0xf8,
-	0x62, 0xe2, 0x53, 0xcd, 0x2f, 0xdf, 0x18, 0xb0, 0x01, 0x53, 0xc3, 0x2d, 0x39, 0xd2, 0xd2, 0xca,
-	0x80, 0xb1, 0x81, 0x4b, 0xb7, 0xd4, 0xec, 0x70, 0x7c, 0xb4, 0x65, 0x8f, 0x39, 0x11, 0x0e, 0xf3,
-	0xf4, 0xef, 0xeb, 0x17, 0x7f, 0x27, 0xde, 0x64, 0x11, 0xf5, 0x0b, 0x4e, 0x7c, 0x9f, 0x72, 0xfd,
-	0xc1, 0xda, 0x69, 0x06, 0x72, 0x7b, 0xcc, 0xa6, 0x3d, 0x9f, 0x5a, 0xe8, 0x3e, 0x18, 0xc4, 0xf3,
-	0x98, 0x50, 0xba, 0x03, 0x33, 0x5d, 0x4d, 0x6f, 0x1a, 0xdb, 0x1b, 0xf5, 0xcb, 0x7b, 0xaa, 0x37,
-	0xa6, 0xb0, 0x66, 0xe6, 0xeb, 0xb3, 0x8d, 0x14, 0x4e, 0x32, 0xd1, 0x4f, 0xa1, 0x60, 0xd3, 0xc0,
-	0xe1, 0xd4, 0xee, 0x73, 0xe6, 0x52, 0x73, 0xa9, 0x9a, 0xde, 0x5c, 0xdb, 0xbe, 0x35, 0x4f, 0x93,
-	0xfc, 0x38, 0x66, 0x2e, 0xc5, 0x86, 0x66, 0xc8, 0x09, 0xba, 0x0f, 0x30, 0xa2, 0xa3, 0x43, 0xca,
-	0x83, 0xa1, 0xe3, 0x9b, 0xcb, 0x8a, 0xfe, 0xf6, 0x22, 0xba, 0x5c, 0x7b, 0xfd, 0x51, 0x0c, 0xc7,
-	0x09, 0x2a, 0x7a, 0x04, 0x05, 0x72, 0x42, 0x1c, 0x97, 0x1c, 0x3a, 0xae, 0x23, 0x26, 0x66, 0x46,
-	0xa9, 0x7a, 0xe7, 0xb9, 0xaa, 0x1a, 0x09, 0x02, 0x9e, 0xa1, 0xd7, 0x6c, 0x80, 0xe9, 0x87, 0xd0,
-	0x5d, 0x58, 0xed, 0xb6, 0xf7, 0x5a, 0x9d, 0xbd, 0xfb, 0xa5, 0x54, 0x79, 0xfd, 0xd9, 0x69, 0xf5,
-	0x55, 0xa9, 0x63, 0x0a, 0xe8, 0x52, 0xcf, 0x76, 0xbc, 0x01, 0xda, 0x84, 0x5c, 0x63, 0x67, 0xa7,
-	0xdd, 0xdd, 0x6f, 0xb7, 0x4a, 0xe9, 0x72, 0xf9, 0xd9, 0x69, 0xf5, 0xb5, 0x59, 0x60, 0xc3, 0xb2,
-	0xa8, 0x2f, 0xa8, 0x5d, 0xce, 0x7c, 0xf5, 0x87, 0x4a, 0xaa, 0xf6, 0x55, 0x1a, 0x0a, 0xc9, 0x45,
-	0xa0, 0xbb, 0x90, 0x6d, 0xec, 0xec, 0x77, 0x0e, 0xda, 0xa5, 0xd4, 0x94, 0x9e, 0x44, 0x34, 0x2c,
-	0xe1, 0x9c, 0x50, 0x74, 0x07, 0x56, 0xba, 0x8d, 0x27, 0xbd, 0x76, 0x29, 0x3d, 0x5d, 0x4e, 0x12,
-	0xd6, 0x25, 0xe3, 0x40, 0xa1, 0x5a, 0xb8, 0xd1, 0xd9, 0x2b, 0x2d, 0xcd, 0x47, 0xb5, 0x38, 0x71,
-	0x3c, 0xbd, 0x94, 0x3f, 0xad, 0x80, 0xd1, 0xa3, 0xfc, 0xc4, 0xb1, 0x5e, 0xb2, 0x8b, 0x7c, 0x08,
-	0x19, 0x41, 0x82, 0x63, 0xe5, 0x1a, 0xc6, 0x7c, 0xd7, 0xd8, 0x27, 0xc1, 0xb1, 0xfc, 0xa8, 0xa6,
-	0x2b, 0xbc, 0xf4, 0x0c, 0x4e, 0x7d, 0xd7, 0xb1, 0x88, 0xa0, 0xb6, 0xf2, 0x0c, 0x63, 0xfb, 0xad,
-	0x79, 0x6c, 0x1c, 0xa3, 0xf4, 0xfa, 0x77, 0x53, 0x38, 0x41, 0x45, 0x9f, 0x40, 0x76, 0xe0, 0xb2,
-	0x43, 0xe2, 0x2a, 0x9f, 0x30, 0xb6, 0xdf, 0x98, 0xa7, 0xe4, 0xbe, 0x42, 0x4c, 0x15, 0x68, 0x0a,
-	0xfa, 0x1c, 0xd6, 0xa6, 0xaa, 0xfa, 0xbf, 0x62, 0x87, 0x26, 0x2c, 0x56, 0x32, 0x5d, 0xc9, 0xe7,
-	0xec, 0x70, 0x37, 0x85, 0x8b, 0x3c, 0x29, 0x40, 0x3f, 0x01, 0x08, 0xb5, 0x2a, 0x3d, 0x86, 0xd2,
-	0x73, 0x7b, 0xf1, 0x62, 0x42, 0x1d, 0xf9, 0x41, 0x34, 0x41, 0x1f, 0x41, 0x76, 0xec, 0xdb, 0x44,
-	0x50, 0x33, 0xab, 0xb8, 0xd5, 0x79, 0xdc, 0x27, 0x0a, 0xb1, 0xc3, 0xbc, 0x23, 0x67, 0x80, 0x35,
-	0x1e, 0xfd, 0x18, 0x72, 0x9c, 0xb9, 0xee, 0x21, 0xb1, 0x8e, 0xcd, 0xfc, 0x0b, 0x72, 0x63, 0x06,
-	0x7a, 0x00, 0x39, 0x8f, 0x8a, 0x2f, 0x18, 0x3f, 0x0e, 0xcc, 0xd5, 0xea, 0xf2, 0xa6, 0xb1, 0xfd,
-	0xde, 0xdc, 0xb0, 0x0a, 0x31, 0x0d, 0x21, 0x88, 0x35, 0x1c, 0x51, 0x4f, 0x84, 0x8a, 0x9a, 0x4b,
-	0x66, 0x1a, 0xc7, 0x0a, 0xe4, 0x52, 0xa8, 0x67, 0xfb, 0xcc, 0xf1, 0x84, 0x99, 0x5b, 0xbc, 0x94,
-	0xb6, 0xc6, 0x48, 0xb7, 0xc0, 0x31, 0xa3, 0x99, 0x85, 0xcc, 0x88, 0xd9, 0xb4, 0xb6, 0x05, 0xd7,
-	0x2f, 0x1d, 0x3b, 0x2a, 0x43, 0x4e, 0x1b, 0x3c, 0xf4, 0xd7, 0x0c, 0x8e, 0xe7, 0xb5, 0x6b, 0x50,
-	0x9c, 0x39, 0xe2, 0x9a, 0x05, 0xc5, 0x99, 0xe3, 0x42, 0x6f, 0xc1, 0xda, 0x88, 0x7c, 0xd9, 0xb7,
-	0x98, 0x67, 0x8d, 0x39, 0xa7, 0x9e, 0xd0, 0x3a, 0x8a, 0x23, 0xf2, 0xe5, 0x4e, 0x2c, 0x44, 0xef,
-	0xc1, 0x75, 0xc1, 0x04, 0x71, 0xfb, 0x16, 0x1b, 0xf9, 0x2e, 0x0d, 0xa3, 0x63, 0x49, 0x21, 0x4b,
-	0xea, 0x87, 0x9d, 0xa9, 0xbc, 0x66, 0x40, 0x3e, 0x3e, 0xcb, 0xda, 0x9f, 0x57, 0x20, 0x17, 0x79,
-	0x3a, 0x7a, 0x00, 0x40, 0x62, 0x43, 0x69, 0x43, 0xbc, 0xf3, 0x42, 0x56, 0x95, 0x74, 0xe9, 0xe1,
-	0x53, 0x3a, 0x6a, 0x40, 0xde, 0x62, 0x9e, 0x20, 0x8e, 0x47, 0xb9, 0x8e, 0xd4, 0xb9, 0xfe, 0xb9,
-	0x13, 0x81, 0xb4, 0x8e, 0x29, 0x0b, 0x35, 0x61, 0x75, 0x40, 0x3d, 0xca, 0x1d, 0x4b, 0x3b, 0xf8,
-	0xdd, 0xb9, 0x8e, 0x19, 0x42, 0xf0, 0xd8, 0x13, 0xce, 0x88, 0x6a, 0x2d, 0x11, 0x11, 0x7d, 0x06,
-	0x79, 0x4e, 0x03, 0x36, 0xe6, 0x16, 0x0d, 0x74, 0xb8, 0x6f, 0xce, 0x0f, 0x93, 0x10, 0x84, 0xe9,
-	0xaf, 0xc7, 0x0e, 0xa7, 0x72, 0x0b, 0x01, 0x9e, 0x52, 0xd1, 0x27, 0xb0, 0xca, 0x69, 0x20, 0x08,
-	0x17, 0xcf, 0x8b, 0x58, 0x1c, 0x42, 0xba, 0xcc, 0x75, 0xac, 0x09, 0x8e, 0x18, 0xe8, 0x13, 0xc8,
-	0xfb, 0x2e, 0xb1, 0x94, 0x56, 0x73, 0x65, 0x71, 0x8c, 0x75, 0x23, 0x10, 0x9e, 0xe2, 0xd1, 0xc7,
-	0x00, 0x2e, 0x1b, 0xf4, 0x6d, 0xee, 0x9c, 0x50, 0xae, 0xa3, 0xac, 0x3c, 0x8f, 0xdd, 0x52, 0x08,
-	0x9c, 0x77, 0xd9, 0x20, 0x1c, 0xa2, 0xfb, 0xff, 0x53, 0x90, 0x24, 0x02, 0xe4, 0x0d, 0x28, 0x1c,
-	0x31, 0x6e, 0xd1, 0xbe, 0x8e, 0xf5, 0xbc, 0xf2, 0x2d, 0x43, 0xc9, 0xc2, 0x00, 0x45, 0xbf, 0x84,
-	0x57, 0x22, 0x6b, 0xf5, 0x39, 0x3d, 0xa2, 0x9c, 0x7a, 0xd2, 0xe4, 0x86, 0xfa, 0xec, 0x5b, 0xcf,
-	0x37, 0xb9, 0x46, 0xeb, 0x54, 0x8b, 0xf8, 0xc5, 0x1f, 0x82, 0x66, 0x1e, 0x56, 0x79, 0x78, 0xc0,
-	0xb5, 0xdf, 0xa6, 0x65, 0x9c, 0x5d, 0x40, 0xa0, 0x2d, 0x30, 0xe2, 0xcf, 0x3b, 0xb6, 0x72, 0xb8,
-	0x7c, 0x73, 0xed, 0xfc, 0x6c, 0x03, 0x22, 0x6c, 0xa7, 0x25, 0x33, 0xb0, 0x1e, 0xdb, 0xa8, 0x0d,
-	0xc5, 0x98, 0x20, 0x8b, 0x20, 0x5d, 0x26, 0x54, 0x9f, 0xb7, 0xd2, 0xfd, 0x89, 0x4f, 0x71, 0x81,
-	0x27, 0x66, 0xb5, 0x5f, 0x00, 0xba, 0xec, 0x80, 0x08, 0x41, 0xe6, 0xd8, 0xf1, 0xf4, 0x32, 0xb0,
-	0x1a, 0xa3, 0x3a, 0xac, 0xfa, 0x64, 0xe2, 0x32, 0x62, 0x6b, 0x3f, 0xbc, 0x51, 0x0f, 0xcb, 0xa3,
-	0x7a, 0x54, 0x1e, 0xd5, 0x1b, 0xde, 0x04, 0x47, 0xa0, 0xda, 0x03, 0x78, 0x75, 0x6e, 0x9c, 0xa1,
-	0x6d, 0x28, 0xc4, 0x31, 0x32, 0xdd, 0xeb, 0xb5, 0xf3, 0xb3, 0x0d, 0x23, 0x0e, 0xa6, 0x4e, 0x0b,
-	0x1b, 0x31, 0xa8, 0x63, 0xd7, 0xfe, 0xba, 0x06, 0xc5, 0x99, 0x48, 0x43, 0x37, 0x60, 0xc5, 0x19,
-	0x91, 0x01, 0xd5, 0x6b, 0x0c, 0x27, 0xa8, 0x0d, 0x59, 0x97, 0x1c, 0x52, 0x57, 0xc6, 0x8a, 0x3c,
-	0xb8, 0x1f, 0x5c, 0x19, 0xb2, 0xf5, 0x87, 0x0a, 0xdf, 0xf6, 0x04, 0x9f, 0x60, 0x4d, 0x46, 0x26,
-	0xac, 0x5a, 0x6c, 0x34, 0x22, 0x9e, 0xbc, 0x24, 0x97, 0x37, 0xf3, 0x38, 0x9a, 0x4a, 0xcb, 0x10,
-	0x3e, 0x08, 0xcc, 0x8c, 0x12, 0xab, 0xb1, 0xcc, 0x91, 0x43, 0x16, 0x08, 0x8f, 0x8c, 0xa8, 0xb9,
-	0xa6, 0x56, 0x13, 0xcf, 0x51, 0x09, 0x96, 0xa9, 0x77, 0x62, 0xae, 0x28, 0xb8, 0x1c, 0x4a, 0x89,
-	0xed, 0x84, 0x81, 0x90, 0xc7, 0x72, 0x28, 0x75, 0x8e, 0x03, 0xca, 0xcd, 0xd5, 0xd0, 0xda, 0x72,
-	0x8c, 0x5e, 0x83, 0xec, 0x80, 0xb3, 0xb1, 0x1f, 0x7a, 0x60, 0x1e, 0xeb, 0x99, 0xbc, 0xef, 0x7c,
-	0xee, 0x9c, 0x38, 0x2e, 0x1d, 0xd0, 0xc0, 0x7c, 0x4d, 0x1d, 0x44, 0x65, 0x6e, 0x2c, 0xc6, 0x28,
-	0x9c, 0x60, 0xa0, 0x3a, 0x64, 0x1c, 0xcf, 0x11, 0xe6, 0xeb, 0x3a, 0x0e, 0x2f, 0x1e, 0x61, 0x93,
-	0x31, 0xf7, 0x80, 0xb8, 0x63, 0x8a, 0x15, 0x0e, 0xad, 0xc3, 0xb2, 0x10, 0x13, 0xb3, 0x58, 0x4d,
-	0x6f, 0xe6, 0x9a, 0xab, 0xe7, 0x67, 0x1b, 0xcb, 0xfb, 0xfb, 0x4f, 0xb1, 0x94, 0xa1, 0xdb, 0x00,
-	0xcc, 0xa7, 0x5e, 0x3f, 0x10, 0xb6, 0xe3, 0x99, 0x48, 0x22, 0x70, 0x5e, 0x4a, 0x7a, 0x52, 0x80,
-	0x6e, 0xca, 0xcc, 0x45, 0xec, 0x3e, 0xf3, 0xdc, 0x89, 0xf9, 0x8a, 0xfa, 0x35, 0x27, 0x05, 0x8f,
-	0x3d, 0x77, 0x82, 0x36, 0xc0, 0x08, 0x04, 0xf3, 0xfb, 0x81, 0x33, 0xf0, 0x88, 0x6b, 0xde, 0x50,
-	0x3b, 0x07, 0x29, 0xea, 0x29, 0x09, 0xfa, 0x11, 0x64, 0x47, 0x6c, 0xec, 0x89, 0xc0, 0xcc, 0xa9,
-	0x83, 0x5c, 0x9f, 0xb7, 0xc7, 0x47, 0x12, 0xa1, 0xa3, 0x4e, 0xc3, 0x51, 0x1b, 0xae, 0x2b, 0xcd,
-	0x03, 0x4e, 0x2c, 0xda, 0xf7, 0x29, 0x77, 0x98, 0xad, 0xef, 0xe7, 0xf5, 0x4b, 0xbb, 0x6d, 0xe9,
-	0x56, 0x00, 0x5f, 0x93, 0x9c, 0xfb, 0x92, 0xd2, 0x55, 0x0c, 0xd4, 0x85, 0x82, 0x3f, 0x76, 0xdd,
-	0x3e, 0xf3, 0xc3, 0xdb, 0x28, 0x4c, 0xe0, 0x2f, 0xe0, 0x4e, 0xdd, 0xb1, 0xeb, 0x3e, 0x0e, 0x49,
-	0xd8, 0xf0, 0xa7, 0x13, 0xf4, 0x29, 0xac, 0x06, 0xd4, 0xe2, 0x54, 0x04, 0x66, 0x41, 0x6d, 0xe9,
-	0xcd, 0x79, 0xca, 0x7a, 0x0a, 0x12, 0xe7, 0x05, 0x1c, 0x71, 0x24, 0xdd, 0x52, 0x69, 0x2d, 0x30,
-	0x5f, 0x5d, 0x4c, 0xd7, 0x99, 0x6f, 0x4a, 0xd7, 0x1c, 0x19, 0x2e, 0xd2, 0x27, 0x03, 0xf3, 0xba,
-	0x72, 0xa7, 0x70, 0x82, 0x9e, 0x02, 0xd8, 0x5e, 0xd0, 0x0f, 0x41, 0xe6, 0x35, 0xb5, 0xc7, 0xf7,
-	0xae, 0xde, 0x63, 0x6b, 0xaf, 0xa7, 0xeb, 0x90, 0xe2, 0xf9, 0xd9, 0x46, 0x3e, 0x9e, 0xe2, 0xbc,
-	0xed, 0x05, 0xe1, 0x10, 0x35, 0xc1, 0x18, 0x52, 0xe2, 0x8a, 0xa1, 0x35, 0xa4, 0xd6, 0xb1, 0x59,
-	0x5a, 0x5c, 0x96, 0xec, 0x2a, 0x98, 0xd6, 0x90, 0x24, 0xa1, 0x0e, 0xe4, 0x9d, 0x80, 0xb9, 0xea,
-	0x88, 0x4c, 0x53, 0xe5, 0xb7, 0x17, 0x58, 0x5d, 0x27, 0xa2, 0xe0, 0x29, 0x1b, 0xdd, 0x82, 0xbc,
-	0xef, 0xd8, 0xc1, 0x43, 0x67, 0xe4, 0x08, 0x73, 0xbd, 0x9a, 0xde, 0x5c, 0xc6, 0x53, 0x01, 0xda,
-	0x85, 0xd5, 0x60, 0x12, 0x58, 0xc2, 0x0d, 0xcc, 0xb2, 0x32, 0x6e, 0xfd, 0xea, 0xcf, 0xf4, 0x42,
-	0x42, 0x98, 0x38, 0x22, 0xba, 0xac, 0x78, 0x2c, 0xe2, 0xeb, 0x5e, 0xa0, 0x4f, 0x6c, 0xdb, 0xbc,
-	0xa9, 0x0c, 0x5e, 0x9c, 0x4a, 0x1b, 0xb6, 0x8d, 0xde, 0x86, 0x6b, 0x09, 0x98, 0xcd, 0x99, 0x6f,
-	0xde, 0x52, 0xb8, 0x04, 0xbb, 0xc5, 0x99, 0x2f, 0x6b, 0x88, 0xb1, 0x2b, 0xd7, 0x18, 0x98, 0xb7,
-	0xd5, 0xca, 0x36, 0xaf, 0x5e, 0xd9, 0x13, 0x45, 0xc0, 0x11, 0xb1, 0xfc, 0x31, 0x18, 0x89, 0x24,
-	0x27, 0x13, 0xd0, 0x31, 0x9d, 0xe8, 0xbc, 0x29, 0x87, 0xd2, 0x39, 0x4e, 0x64, 0xcc, 0xab, 0xc4,
-	0x9e, 0xc7, 0xe1, 0xe4, 0xde, 0xd2, 0x47, 0xe9, 0xf2, 0x36, 0x18, 0x09, 0x87, 0x46, 0x6f, 0xca,
-	0x4b, 0x67, 0xe0, 0x04, 0x82, 0x4f, 0xfa, 0x64, 0x2c, 0x86, 0xe6, 0xcf, 0x14, 0xa1, 0x10, 0x09,
-	0x1b, 0x63, 0x31, 0x2c, 0xf7, 0x61, 0xea, 0x11, 0xa8, 0x0a, 0x86, 0xcc, 0x83, 0x01, 0xe5, 0x27,
-	0x94, 0xcb, 0x12, 0x52, 0x6e, 0x32, 0x29, 0x92, 0x99, 0x2e, 0xa0, 0x84, 0x5b, 0x43, 0x95, 0xb2,
-	0xf3, 0x58, 0xcf, 0x64, 0x0e, 0x8e, 0x82, 0x4f, 0xe7, 0x60, 0x3d, 0x2d, 0xdf, 0x83, 0x42, 0xd2,
-	0xf8, 0xff, 0xd5, 0x86, 0x5a, 0x90, 0x0d, 0xcd, 0x23, 0xb3, 0xae, 0xca, 0xd8, 0xfa, 0x8e, 0x53,
-	0xd9, 0x1a, 0x41, 0x26, 0x60, 0x47, 0x42, 0xd1, 0x96, 0xb1, 0x1a, 0x4b, 0xd9, 0x90, 0xf0, 0xb0,
-	0x5b, 0x5a, 0xc6, 0x6a, 0x5c, 0xfb, 0x4b, 0x1a, 0xf2, 0xb1, 0x9b, 0xa1, 0x0f, 0xe0, 0x7a, 0xa7,
-	0xf7, 0xf8, 0x61, 0x63, 0xbf, 0xf3, 0x78, 0xaf, 0xdf, 0x6a, 0x7f, 0xd6, 0x78, 0xf2, 0x70, 0xbf,
-	0x94, 0x2a, 0xdf, 0x7e, 0x76, 0x5a, 0x5d, 0x9f, 0xde, 0x68, 0x11, 0xbc, 0x45, 0x8f, 0xc8, 0xd8,
-	0x15, 0xb3, 0xac, 0x2e, 0x7e, 0xbc, 0xd3, 0xee, 0xf5, 0x4a, 0xe9, 0x45, 0xac, 0x2e, 0x67, 0x16,
-	0x0d, 0x02, 0xb4, 0x0d, 0xa5, 0x29, 0x6b, 0xf7, 0x69, 0xb7, 0x8d, 0x0f, 0x4a, 0x4b, 0xe5, 0x5b,
-	0xcf, 0x4e, 0xab, 0xe6, 0x65, 0xd2, 0xee, 0xc4, 0xa7, 0xfc, 0x40, 0x37, 0xa3, 0xff, 0x4c, 0x43,
-	0x21, 0xd9, 0x01, 0xa0, 0x9d, 0xb0, 0xee, 0x57, 0x06, 0x58, 0xdb, 0xde, 0xba, 0xaa, 0x63, 0x50,
-	0x55, 0x84, 0x3b, 0x96, 0x7a, 0x1f, 0x31, 0x9b, 0x62, 0x45, 0x46, 0x1f, 0xc0, 0x8a, 0xcf, 0xb8,
-	0x88, 0xee, 0xdb, 0xf9, 0x57, 0x11, 0xe3, 0x51, 0x49, 0x16, 0x82, 0x6b, 0x43, 0x58, 0x9b, 0xd5,
-	0x86, 0xee, 0xc0, 0xf2, 0x41, 0xa7, 0x5b, 0x4a, 0x95, 0x6f, 0x3e, 0x3b, 0xad, 0xbe, 0x3e, 0xfb,
-	0xe3, 0x81, 0xc3, 0xc5, 0x98, 0xb8, 0x9d, 0x2e, 0x7a, 0x17, 0x56, 0x5a, 0x7b, 0x3d, 0x8c, 0x4b,
-	0xe9, 0xf2, 0xc6, 0xb3, 0xd3, 0xea, 0xcd, 0x59, 0x9c, 0xfc, 0x89, 0x8d, 0x3d, 0x1b, 0xb3, 0xc3,
-	0xb8, 0x05, 0xff, 0xd7, 0x12, 0x18, 0xba, 0x0c, 0x79, 0xd9, 0xaf, 0x34, 0xc5, 0xb0, 0xa4, 0x8d,
-	0xb2, 0xe7, 0xd2, 0x95, 0x95, 0x6d, 0x21, 0x24, 0xe8, 0xc8, 0x78, 0x03, 0x0a, 0x8e, 0x7f, 0xf2,
-	0x61, 0x9f, 0x7a, 0xe4, 0xd0, 0xd5, 0xdd, 0x78, 0x0e, 0x1b, 0x52, 0xd6, 0x0e, 0x45, 0xb2, 0xb0,
-	0x70, 0x3c, 0x41, 0xb9, 0xa7, 0xfb, 0xec, 0x1c, 0x8e, 0xe7, 0xe8, 0x53, 0xc8, 0x38, 0x3e, 0x19,
-	0xe9, 0x72, 0x7c, 0xee, 0x0e, 0x3a, 0xdd, 0xc6, 0x23, 0x1d, 0xb9, 0xcd, 0xdc, 0xf9, 0xd9, 0x46,
-	0x46, 0x0a, 0xb0, 0xa2, 0xa1, 0x4a, 0xd4, 0x2b, 0xc9, 0x2f, 0xa9, 0x62, 0x24, 0x87, 0x13, 0x12,
-	0x19, 0x7d, 0x8e, 0x37, 0xe0, 0x34, 0x08, 0x54, 0x59, 0x92, 0xc3, 0xd1, 0x14, 0x95, 0x61, 0x55,
-	0xd7, 0xd5, 0xaa, 0xc5, 0xca, 0xcb, 0x6e, 0x45, 0x0b, 0x9a, 0x45, 0x30, 0x42, 0x6b, 0xf4, 0x8f,
-	0x38, 0x1b, 0xd5, 0xfe, 0x9d, 0x01, 0x63, 0xc7, 0x1d, 0x07, 0x42, 0xd7, 0x6c, 0x2f, 0xcd, 0xf8,
-	0x4f, 0xe1, 0x3a, 0x51, 0xaf, 0x3e, 0xc4, 0x93, 0x97, 0xbc, 0x6a, 0x57, 0xf4, 0x01, 0xdc, 0x99,
-	0xab, 0x2e, 0x06, 0x87, 0xad, 0x4d, 0x33, 0x2b, 0x75, 0x9a, 0x69, 0x5c, 0x22, 0x17, 0x7e, 0x41,
-	0x3d, 0x28, 0x32, 0x6e, 0x0d, 0x69, 0x20, 0xc2, 0xd2, 0x40, 0xbf, 0x92, 0xcc, 0x7d, 0x3f, 0x7b,
-	0x9c, 0x04, 0xea, 0x1b, 0x31, 0x5c, 0xed, 0xac, 0x0e, 0xf4, 0x11, 0x64, 0x38, 0x39, 0x8a, 0x5a,
-	0xaf, 0xb9, 0x41, 0x82, 0xc9, 0x91, 0x98, 0x51, 0xa1, 0x18, 0xe8, 0x73, 0x00, 0xdb, 0x09, 0x7c,
-	0x22, 0xac, 0x21, 0xe5, 0xfa, 0xb0, 0xe7, 0x6e, 0xb1, 0x15, 0xa3, 0x66, 0xb4, 0x24, 0xd8, 0xe8,
-	0x01, 0xe4, 0x2d, 0x12, 0xb9, 0x6b, 0x76, 0xf1, 0xd3, 0xd1, 0x4e, 0x43, 0xab, 0x28, 0x49, 0x15,
-	0xe7, 0x67, 0x1b, 0xb9, 0x48, 0x82, 0x73, 0x16, 0xd1, 0xee, 0xfb, 0x00, 0x8a, 0x82, 0x04, 0xc7,
-	0x7d, 0x3b, 0x4c, 0x67, 0xa1, 0x9b, 0x2c, 0xb8, 0xe1, 0x65, 0x87, 0xae, 0xd3, 0x5e, 0x74, 0x9c,
-	0x05, 0x91, 0x90, 0xa1, 0x9f, 0xc3, 0x75, 0xea, 0x59, 0x7c, 0xa2, 0x9c, 0x35, 0x5a, 0x61, 0x6e,
-	0xf1, 0x66, 0xdb, 0x31, 0x78, 0x66, 0xb3, 0x25, 0x7a, 0x41, 0x5e, 0xfb, 0x7b, 0x1a, 0x20, 0x2c,
-	0xa9, 0x5e, 0xae, 0x03, 0x22, 0xc8, 0xd8, 0x44, 0x10, 0xe5, 0x73, 0x05, 0xac, 0xc6, 0xe8, 0x1e,
-	0x80, 0xa0, 0x23, 0x5f, 0xa6, 0x5e, 0x6f, 0xa0, 0xdd, 0xe6, 0x79, 0xe9, 0x20, 0x81, 0x46, 0xdb,
-	0x90, 0xd5, 0x0d, 0x72, 0xe6, 0x4a, 0x9e, 0x46, 0xd6, 0xfe, 0x98, 0x06, 0x08, 0xb7, 0xf9, 0x7f,
-	0xbd, 0xb7, 0xda, 0xdf, 0x56, 0x00, 0x0e, 0x98, 0x3b, 0x1e, 0xbd, 0xe4, 0x47, 0xd0, 0x1b, 0xb0,
-	0xa2, 0x9a, 0xa2, 0xe8, 0x92, 0x57, 0x93, 0x84, 0x25, 0x97, 0x5f, 0xd4, 0x92, 0xa8, 0x0d, 0x86,
-	0xcc, 0x03, 0x41, 0xd0, 0x57, 0x17, 0x62, 0x66, 0xb1, 0xe3, 0x85, 0xfb, 0x68, 0x28, 0xb0, 0xba,
-	0x05, 0x81, 0xc4, 0x63, 0x74, 0x6f, 0x5a, 0xe1, 0xaf, 0xa8, 0xdb, 0xb0, 0xba, 0x58, 0x85, 0xae,
-	0xf3, 0xe3, 0xf2, 0x9e, 0xc2, 0x7a, 0xa8, 0xd5, 0xd1, 0x4f, 0xe7, 0x89, 0x77, 0x1c, 0x1d, 0xab,
-	0x73, 0x53, 0xd0, 0x3e, 0xf3, 0x99, 0xcb, 0x06, 0x49, 0x3c, 0x5e, 0xac, 0x09, 0xed, 0x86, 0xe5,
-	0xa9, 0x25, 0xab, 0x4e, 0x4e, 0xbc, 0x01, 0xd5, 0x61, 0x3b, 0xff, 0x69, 0x4b, 0x23, 0xb1, 0x04,
-	0x86, 0x15, 0x6c, 0x3c, 0x45, 0x4f, 0x2e, 0xfc, 0x37, 0x90, 0x53, 0x55, 0xc4, 0xfb, 0xcf, 0xd9,
-	0xb1, 0xac, 0x21, 0xb4, 0xfd, 0x16, 0xff, 0x47, 0xf0, 0xfb, 0x34, 0xa0, 0xcb, 0x20, 0xb4, 0x99,
-	0x78, 0xc3, 0x57, 0xc5, 0xce, 0x65, 0x8c, 0x7e, 0xc5, 0xbf, 0x3b, 0x7d, 0xc5, 0x57, 0xa5, 0xc4,
-	0x65, 0x60, 0xf8, 0x8e, 0x7f, 0x77, 0xfa, 0x8e, 0xbf, 0x00, 0x97, 0x78, 0xc9, 0x6f, 0xde, 0xf9,
-	0xfa, 0xbb, 0x4a, 0xea, 0xdb, 0xef, 0x2a, 0xa9, 0xdf, 0x9c, 0x57, 0xd2, 0x5f, 0x9f, 0x57, 0xd2,
-	0xdf, 0x9c, 0x57, 0xd2, 0xff, 0x38, 0xaf, 0xa4, 0x7f, 0xf7, 0x7d, 0x25, 0xf5, 0xcd, 0xf7, 0x95,
-	0xd4, 0xb7, 0xdf, 0x57, 0x52, 0x87, 0x59, 0xd5, 0x58, 0xfe, 0xf0, 0x3f, 0x01, 0x00, 0x00, 0xff,
-	0xff, 0xd2, 0x36, 0x0b, 0x87, 0xf5, 0x1a, 0x00, 0x00,
+	// 2373 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x4d, 0x73, 0x1b, 0xc7,
+	0xd1, 0x06, 0x48, 0x10, 0x1f, 0xbd, 0x00, 0x05, 0x8e, 0x65, 0x7b, 0x09, 0x49, 0x20, 0x0c, 0xcb,
+	0x36, 0x6d, 0xd7, 0x0b, 0xd6, 0xcb, 0xb8, 0x1c, 0x7f, 0xc4, 0x49, 0x00, 0x02, 0x96, 0x60, 0x49,
+	0x14, 0x6a, 0x40, 0x29, 0x51, 0x55, 0xaa, 0x50, 0x83, 0xdd, 0x21, 0xb0, 0xe1, 0x62, 0x67, 0x33,
+	0x3b, 0xa0, 0x8d, 0x5b, 0x8e, 0x2e, 0xe5, 0x92, 0x3f, 0xc0, 0x53, 0x2a, 0xa7, 0x5c, 0x92, 0x7f,
+	0xe1, 0xa3, 0x8f, 0xce, 0x85, 0x65, 0xd3, 0x3f, 0x21, 0xb7, 0x5c, 0x92, 0x9a, 0xd9, 0xd9, 0xc5,
+	0x82, 0x02, 0x44, 0xa5, 0xa2, 0x43, 0x6e, 0x33, 0xbd, 0xcf, 0xd3, 0xd3, 0x33, 0xd3, 0xdd, 0xd3,
+	0xbd, 0xf0, 0xde, 0xc8, 0x11, 0xe3, 0xe9, 0xb0, 0x61, 0xb1, 0xc9, 0x9e, 0xcd, 0xac, 0x13, 0xca,
+	0xf7, 0x82, 0x2f, 0x09, 0x9f, 0x9c, 0x38, 0x62, 0x8f, 0xf8, 0xce, 0x5e, 0xe0, 0x53, 0x2b, 0x68,
+	0xf8, 0x9c, 0x09, 0x86, 0x50, 0x08, 0x68, 0x44, 0x80, 0xc6, 0xe9, 0xff, 0x57, 0xae, 0xe2, 0x8b,
+	0x99, 0x4f, 0x35, 0xbf, 0x72, 0x7d, 0xc4, 0x46, 0x4c, 0x0d, 0xf7, 0xe4, 0x48, 0x4b, 0xab, 0x23,
+	0xc6, 0x46, 0x2e, 0xdd, 0x53, 0xb3, 0xe1, 0xf4, 0x78, 0xcf, 0x9e, 0x72, 0x22, 0x1c, 0xe6, 0xe9,
+	0xef, 0xdb, 0x97, 0xbf, 0x13, 0x6f, 0xb6, 0x8a, 0xfa, 0x25, 0x27, 0xbe, 0x4f, 0xb9, 0x5e, 0xb0,
+	0x7e, 0x96, 0x81, 0xfc, 0x21, 0xb3, 0x69, 0xdf, 0xa7, 0x16, 0xba, 0x03, 0x06, 0xf1, 0x3c, 0x26,
+	0x94, 0xee, 0xc0, 0x4c, 0xd7, 0xd2, 0xbb, 0xc6, 0xfe, 0x4e, 0xe3, 0xd9, 0x3d, 0x35, 0x9a, 0x73,
+	0x58, 0x2b, 0xf3, 0xcd, 0xf9, 0x4e, 0x0a, 0x27, 0x99, 0xe8, 0x17, 0x50, 0xb4, 0x69, 0xe0, 0x70,
+	0x6a, 0x0f, 0x38, 0x73, 0xa9, 0xb9, 0x56, 0x4b, 0xef, 0x6e, 0xee, 0xdf, 0x5c, 0xa6, 0x49, 0x2e,
+	0x8e, 0x99, 0x4b, 0xb1, 0xa1, 0x19, 0x72, 0x82, 0xee, 0x00, 0x4c, 0xe8, 0x64, 0x48, 0x79, 0x30,
+	0x76, 0x7c, 0x73, 0x5d, 0xd1, 0xdf, 0x59, 0x45, 0x97, 0xb6, 0x37, 0x1e, 0xc4, 0x70, 0x9c, 0xa0,
+	0xa2, 0x07, 0x50, 0x24, 0xa7, 0xc4, 0x71, 0xc9, 0xd0, 0x71, 0x1d, 0x31, 0x33, 0x33, 0x4a, 0xd5,
+	0xbb, 0xcf, 0x55, 0xd5, 0x4c, 0x10, 0xf0, 0x02, 0xbd, 0x6e, 0x03, 0xcc, 0x17, 0x42, 0x6f, 0x43,
+	0xae, 0xd7, 0x39, 0x6c, 0x77, 0x0f, 0xef, 0x94, 0x53, 0x95, 0xed, 0xa7, 0x67, 0xb5, 0x57, 0xa5,
+	0x8e, 0x39, 0xa0, 0x47, 0x3d, 0xdb, 0xf1, 0x46, 0x68, 0x17, 0xf2, 0xcd, 0x83, 0x83, 0x4e, 0xef,
+	0xa8, 0xd3, 0x2e, 0xa7, 0x2b, 0x95, 0xa7, 0x67, 0xb5, 0xd7, 0x16, 0x81, 0x4d, 0xcb, 0xa2, 0xbe,
+	0xa0, 0x76, 0x25, 0xf3, 0xf5, 0x9f, 0xaa, 0xa9, 0xfa, 0xd7, 0x69, 0x28, 0x26, 0x8d, 0x40, 0x6f,
+	0x43, 0xb6, 0x79, 0x70, 0xd4, 0x7d, 0xdc, 0x29, 0xa7, 0xe6, 0xf4, 0x24, 0xa2, 0x69, 0x09, 0xe7,
+	0x94, 0xa2, 0xdb, 0xb0, 0xd1, 0x6b, 0x3e, 0xea, 0x77, 0xca, 0xe9, 0xb9, 0x39, 0x49, 0x58, 0x8f,
+	0x4c, 0x03, 0x85, 0x6a, 0xe3, 0x66, 0xf7, 0xb0, 0xbc, 0xb6, 0x1c, 0xd5, 0xe6, 0xc4, 0xf1, 0xb4,
+	0x29, 0x7f, 0xd9, 0x00, 0xa3, 0x4f, 0xf9, 0xa9, 0x63, 0xbd, 0x64, 0x17, 0xf9, 0x10, 0x32, 0x82,
+	0x04, 0x27, 0xca, 0x35, 0x8c, 0xe5, 0xae, 0x71, 0x44, 0x82, 0x13, 0xb9, 0xa8, 0xa6, 0x2b, 0xbc,
+	0xf4, 0x0c, 0x4e, 0x7d, 0xd7, 0xb1, 0x88, 0xa0, 0xb6, 0xf2, 0x0c, 0x63, 0xff, 0xad, 0x65, 0x6c,
+	0x1c, 0xa3, 0xb4, 0xfd, 0x77, 0x53, 0x38, 0x41, 0x45, 0x9f, 0x42, 0x76, 0xe4, 0xb2, 0x21, 0x71,
+	0x95, 0x4f, 0x18, 0xfb, 0x6f, 0x2c, 0x53, 0x72, 0x47, 0x21, 0xe6, 0x0a, 0x34, 0x05, 0x7d, 0x01,
+	0x9b, 0x73, 0x55, 0x83, 0xdf, 0xb2, 0xa1, 0x09, 0xab, 0x95, 0xcc, 0x2d, 0xf9, 0x82, 0x0d, 0xef,
+	0xa6, 0x70, 0x89, 0x27, 0x05, 0xe8, 0xe7, 0x00, 0xa1, 0x56, 0xa5, 0xc7, 0x50, 0x7a, 0x6e, 0xad,
+	0x36, 0x26, 0xd4, 0x51, 0x18, 0x45, 0x13, 0xf4, 0x11, 0x64, 0xa7, 0xbe, 0x4d, 0x04, 0x35, 0xb3,
+	0x8a, 0x5b, 0x5b, 0xc6, 0x7d, 0xa4, 0x10, 0x07, 0xcc, 0x3b, 0x76, 0x46, 0x58, 0xe3, 0xd1, 0xcf,
+	0x20, 0xcf, 0x99, 0xeb, 0x0e, 0x89, 0x75, 0x62, 0x16, 0x5e, 0x90, 0x1b, 0x33, 0xd0, 0x3d, 0xc8,
+	0x7b, 0x54, 0x7c, 0xc9, 0xf8, 0x49, 0x60, 0xe6, 0x6a, 0xeb, 0xbb, 0xc6, 0xfe, 0xfb, 0x4b, 0xc3,
+	0x2a, 0xc4, 0x34, 0x85, 0x20, 0xd6, 0x78, 0x42, 0x3d, 0x11, 0x2a, 0x6a, 0xad, 0x99, 0x69, 0x1c,
+	0x2b, 0x90, 0xa6, 0x50, 0xcf, 0xf6, 0x99, 0xe3, 0x09, 0x33, 0xbf, 0xda, 0x94, 0x8e, 0xc6, 0x48,
+	0xb7, 0xc0, 0x31, 0xa3, 0x95, 0x85, 0xcc, 0x84, 0xd9, 0xb4, 0xbe, 0x07, 0x5b, 0xcf, 0x5c, 0x3b,
+	0xaa, 0x40, 0x5e, 0x1f, 0x78, 0xe8, 0xaf, 0x19, 0x1c, 0xcf, 0xeb, 0xd7, 0xa0, 0xb4, 0x70, 0xc5,
+	0x75, 0x0b, 0x4a, 0x0b, 0xd7, 0x85, 0xde, 0x82, 0xcd, 0x09, 0xf9, 0x6a, 0x60, 0x31, 0xcf, 0x9a,
+	0x72, 0x4e, 0x3d, 0xa1, 0x75, 0x94, 0x26, 0xe4, 0xab, 0x83, 0x58, 0x88, 0xde, 0x87, 0x2d, 0xc1,
+	0x04, 0x71, 0x07, 0x16, 0x9b, 0xf8, 0x2e, 0x0d, 0xa3, 0x63, 0x4d, 0x21, 0xcb, 0xea, 0xc3, 0xc1,
+	0x5c, 0x5e, 0x37, 0xa0, 0x10, 0xdf, 0x65, 0xfd, 0xaf, 0x1b, 0x90, 0x8f, 0x3c, 0x1d, 0xdd, 0x03,
+	0x20, 0xf1, 0x41, 0xe9, 0x83, 0x78, 0xf7, 0x85, 0x4e, 0x55, 0xd2, 0xa5, 0x87, 0xcf, 0xe9, 0xa8,
+	0x09, 0x05, 0x8b, 0x79, 0x82, 0x38, 0x1e, 0xe5, 0x3a, 0x52, 0x97, 0xfa, 0xe7, 0x41, 0x04, 0xd2,
+	0x3a, 0xe6, 0x2c, 0xd4, 0x82, 0xdc, 0x88, 0x7a, 0x94, 0x3b, 0x96, 0x76, 0xf0, 0xb7, 0x97, 0x3a,
+	0x66, 0x08, 0xc1, 0x53, 0x4f, 0x38, 0x13, 0xaa, 0xb5, 0x44, 0x44, 0xf4, 0x39, 0x14, 0x38, 0x0d,
+	0xd8, 0x94, 0x5b, 0x34, 0xd0, 0xe1, 0xbe, 0xbb, 0x3c, 0x4c, 0x42, 0x10, 0xa6, 0xbf, 0x9b, 0x3a,
+	0x9c, 0xca, 0x2d, 0x04, 0x78, 0x4e, 0x45, 0x9f, 0x42, 0x8e, 0xd3, 0x40, 0x10, 0x2e, 0x9e, 0x17,
+	0xb1, 0x38, 0x84, 0xf4, 0x98, 0xeb, 0x58, 0x33, 0x1c, 0x31, 0xd0, 0xa7, 0x50, 0xf0, 0x5d, 0x62,
+	0x29, 0xad, 0xe6, 0xc6, 0xea, 0x18, 0xeb, 0x45, 0x20, 0x3c, 0xc7, 0xa3, 0x8f, 0x01, 0x5c, 0x36,
+	0x1a, 0xd8, 0xdc, 0x39, 0xa5, 0x5c, 0x47, 0x59, 0x65, 0x19, 0xbb, 0xad, 0x10, 0xb8, 0xe0, 0xb2,
+	0x51, 0x38, 0x44, 0x77, 0xfe, 0xab, 0x20, 0x49, 0x04, 0xc8, 0x1b, 0x50, 0x3c, 0x66, 0xdc, 0xa2,
+	0x03, 0x1d, 0xeb, 0x05, 0xe5, 0x5b, 0x86, 0x92, 0x85, 0x01, 0x8a, 0x7e, 0x03, 0xaf, 0x44, 0xa7,
+	0x35, 0xe0, 0xf4, 0x98, 0x72, 0xea, 0xc9, 0x23, 0x37, 0xd4, 0xb2, 0x6f, 0x3d, 0xff, 0xc8, 0x35,
+	0x5a, 0xa7, 0x5a, 0xc4, 0x2f, 0x7f, 0x08, 0x5a, 0x05, 0xc8, 0xf1, 0xf0, 0x82, 0xeb, 0x7f, 0x48,
+	0xcb, 0x38, 0xbb, 0x84, 0x40, 0x7b, 0x60, 0xc4, 0xcb, 0x3b, 0xb6, 0x72, 0xb8, 0x42, 0x6b, 0xf3,
+	0xe2, 0x7c, 0x07, 0x22, 0x6c, 0xb7, 0x2d, 0x33, 0xb0, 0x1e, 0xdb, 0xa8, 0x03, 0xa5, 0x98, 0x20,
+	0x8b, 0x20, 0x5d, 0x26, 0xd4, 0x9e, 0x67, 0xe9, 0xd1, 0xcc, 0xa7, 0xb8, 0xc8, 0x13, 0xb3, 0xfa,
+	0xaf, 0x01, 0x3d, 0xeb, 0x80, 0x08, 0x41, 0xe6, 0xc4, 0xf1, 0xb4, 0x19, 0x58, 0x8d, 0x51, 0x03,
+	0x72, 0x3e, 0x99, 0xb9, 0x8c, 0xd8, 0xda, 0x0f, 0xaf, 0x37, 0xc2, 0xf2, 0xa8, 0x11, 0x95, 0x47,
+	0x8d, 0xa6, 0x37, 0xc3, 0x11, 0xa8, 0x7e, 0x0f, 0x5e, 0x5d, 0x1a, 0x67, 0x68, 0x1f, 0x8a, 0x71,
+	0x8c, 0xcc, 0xf7, 0x7a, 0xed, 0xe2, 0x7c, 0xc7, 0x88, 0x83, 0xa9, 0xdb, 0xc6, 0x46, 0x0c, 0xea,
+	0xda, 0xf5, 0xef, 0x37, 0xa1, 0xb4, 0x10, 0x69, 0xe8, 0x3a, 0x6c, 0x38, 0x13, 0x32, 0xa2, 0xda,
+	0xc6, 0x70, 0x82, 0x3a, 0x90, 0x75, 0xc9, 0x90, 0xba, 0x32, 0x56, 0xe4, 0xc5, 0xfd, 0xdf, 0x95,
+	0x21, 0xdb, 0xb8, 0xaf, 0xf0, 0x1d, 0x4f, 0xf0, 0x19, 0xd6, 0x64, 0x64, 0x42, 0xce, 0x62, 0x93,
+	0x09, 0xf1, 0xe4, 0x23, 0xb9, 0xbe, 0x5b, 0xc0, 0xd1, 0x54, 0x9e, 0x0c, 0xe1, 0xa3, 0xc0, 0xcc,
+	0x28, 0xb1, 0x1a, 0xcb, 0x1c, 0x39, 0x66, 0x81, 0xf0, 0xc8, 0x84, 0x9a, 0x9b, 0xca, 0x9a, 0x78,
+	0x8e, 0xca, 0xb0, 0x4e, 0xbd, 0x53, 0x73, 0x43, 0xc1, 0xe5, 0x50, 0x4a, 0x6c, 0x27, 0x0c, 0x84,
+	0x02, 0x96, 0x43, 0xa9, 0x73, 0x1a, 0x50, 0x6e, 0xe6, 0xc2, 0xd3, 0x96, 0x63, 0xf4, 0x1a, 0x64,
+	0x47, 0x9c, 0x4d, 0xfd, 0xd0, 0x03, 0x0b, 0x58, 0xcf, 0xe4, 0x7b, 0xe7, 0x73, 0xe7, 0xd4, 0x71,
+	0xe9, 0x88, 0x06, 0xe6, 0x6b, 0xea, 0x22, 0xaa, 0x4b, 0x63, 0x31, 0x46, 0xe1, 0x04, 0x03, 0x35,
+	0x20, 0xe3, 0x78, 0x8e, 0x30, 0x5f, 0xd7, 0x71, 0x78, 0xf9, 0x0a, 0x5b, 0x8c, 0xb9, 0x8f, 0x89,
+	0x3b, 0xa5, 0x58, 0xe1, 0xd0, 0x36, 0xac, 0x0b, 0x31, 0x33, 0x4b, 0xb5, 0xf4, 0x6e, 0xbe, 0x95,
+	0xbb, 0x38, 0xdf, 0x59, 0x3f, 0x3a, 0x7a, 0x82, 0xa5, 0x0c, 0xdd, 0x02, 0x60, 0x3e, 0xf5, 0x06,
+	0x81, 0xb0, 0x1d, 0xcf, 0x44, 0x12, 0x81, 0x0b, 0x52, 0xd2, 0x97, 0x02, 0x74, 0x43, 0x66, 0x2e,
+	0x62, 0x0f, 0x98, 0xe7, 0xce, 0xcc, 0x57, 0xd4, 0xd7, 0xbc, 0x14, 0x3c, 0xf4, 0xdc, 0x19, 0xda,
+	0x01, 0x23, 0x10, 0xcc, 0x1f, 0x04, 0xce, 0xc8, 0x23, 0xae, 0x79, 0x5d, 0xed, 0x1c, 0xa4, 0xa8,
+	0xaf, 0x24, 0xe8, 0xa7, 0x90, 0x9d, 0xb0, 0xa9, 0x27, 0x02, 0x33, 0xaf, 0x2e, 0x72, 0x7b, 0xd9,
+	0x1e, 0x1f, 0x48, 0x84, 0x8e, 0x3a, 0x0d, 0x47, 0x1d, 0xd8, 0x52, 0x9a, 0x47, 0x9c, 0x58, 0x74,
+	0xe0, 0x53, 0xee, 0x30, 0x5b, 0xbf, 0xcf, 0xdb, 0xcf, 0xec, 0xb6, 0xad, 0x5b, 0x01, 0x7c, 0x4d,
+	0x72, 0xee, 0x48, 0x4a, 0x4f, 0x31, 0x50, 0x0f, 0x8a, 0xfe, 0xd4, 0x75, 0x07, 0xcc, 0x0f, 0x5f,
+	0xa3, 0x30, 0x81, 0xbf, 0x80, 0x3b, 0xf5, 0xa6, 0xae, 0xfb, 0x30, 0x24, 0x61, 0xc3, 0x9f, 0x4f,
+	0xd0, 0x67, 0x90, 0x0b, 0xa8, 0xc5, 0xa9, 0x08, 0xcc, 0xa2, 0xda, 0xd2, 0x9b, 0xcb, 0x94, 0xf5,
+	0x15, 0x24, 0xce, 0x0b, 0x38, 0xe2, 0x48, 0xba, 0xa5, 0xd2, 0x5a, 0x60, 0xbe, 0xba, 0x9a, 0xae,
+	0x33, 0xdf, 0x9c, 0xae, 0x39, 0x32, 0x5c, 0xa4, 0x4f, 0x06, 0xe6, 0x96, 0x72, 0xa7, 0x70, 0x82,
+	0x9e, 0x00, 0xd8, 0x5e, 0x30, 0x08, 0x41, 0xe6, 0x35, 0xb5, 0xc7, 0xf7, 0xaf, 0xde, 0x63, 0xfb,
+	0xb0, 0xaf, 0xeb, 0x90, 0xd2, 0xc5, 0xf9, 0x4e, 0x21, 0x9e, 0xe2, 0x82, 0xed, 0x05, 0xe1, 0x10,
+	0xb5, 0xc0, 0x18, 0x53, 0xe2, 0x8a, 0xb1, 0x35, 0xa6, 0xd6, 0x89, 0x59, 0x5e, 0x5d, 0x96, 0xdc,
+	0x55, 0x30, 0xad, 0x21, 0x49, 0x42, 0x5d, 0x28, 0x38, 0x01, 0x73, 0xd5, 0x15, 0x99, 0xa6, 0xca,
+	0x6f, 0x2f, 0x60, 0x5d, 0x37, 0xa2, 0xe0, 0x39, 0x1b, 0xdd, 0x84, 0x82, 0xef, 0xd8, 0xc1, 0x7d,
+	0x67, 0xe2, 0x08, 0x73, 0xbb, 0x96, 0xde, 0x5d, 0xc7, 0x73, 0x01, 0xba, 0x0b, 0xb9, 0x60, 0x16,
+	0x58, 0xc2, 0x0d, 0xcc, 0x8a, 0x3a, 0xdc, 0xc6, 0xd5, 0xcb, 0xf4, 0x43, 0x42, 0x98, 0x38, 0x22,
+	0xba, 0xac, 0x78, 0x2c, 0xe2, 0xeb, 0x5e, 0x60, 0x40, 0x6c, 0xdb, 0xbc, 0xa1, 0x0e, 0xbc, 0x34,
+	0x97, 0x36, 0x6d, 0x1b, 0xbd, 0x03, 0xd7, 0x12, 0x30, 0x9b, 0x33, 0xdf, 0xbc, 0xa9, 0x70, 0x09,
+	0x76, 0x9b, 0x33, 0x5f, 0xd6, 0x10, 0x53, 0x57, 0xda, 0x18, 0x98, 0xb7, 0x94, 0x65, 0xbb, 0x57,
+	0x5b, 0xf6, 0x48, 0x11, 0x70, 0x44, 0x44, 0xd5, 0x44, 0xce, 0xb0, 0xcd, 0xaa, 0x0a, 0xc5, 0x84,
+	0xa4, 0xf2, 0x31, 0x18, 0x89, 0x24, 0x28, 0x13, 0xd4, 0x09, 0x9d, 0xe9, 0xbc, 0x2a, 0x87, 0xd2,
+	0x79, 0x4e, 0x65, 0x4e, 0x50, 0x89, 0xbf, 0x80, 0xc3, 0xc9, 0x27, 0x6b, 0x1f, 0xa5, 0x2b, 0xfb,
+	0x60, 0x24, 0x1c, 0x1e, 0xbd, 0x29, 0x1f, 0xa5, 0x91, 0x13, 0x08, 0x3e, 0x1b, 0x90, 0xa9, 0x18,
+	0x9b, 0xbf, 0x54, 0x84, 0x62, 0x24, 0x6c, 0x4e, 0xc5, 0xb8, 0x32, 0x80, 0xb9, 0xc7, 0xa0, 0x1a,
+	0x18, 0x32, 0x4f, 0x06, 0x94, 0x9f, 0x52, 0x2e, 0x4b, 0x4c, 0x79, 0x08, 0x49, 0x91, 0xcc, 0x84,
+	0x01, 0x25, 0xdc, 0x1a, 0xab, 0x94, 0x5e, 0xc0, 0x7a, 0x26, 0x73, 0x74, 0x14, 0x9c, 0x3a, 0x47,
+	0xeb, 0x69, 0xe5, 0x13, 0x28, 0x26, 0x2f, 0xe7, 0x3f, 0xda, 0x50, 0x1b, 0xb2, 0xe1, 0xf1, 0xc9,
+	0xac, 0xac, 0x32, 0xba, 0x7e, 0x03, 0x55, 0x36, 0x47, 0x90, 0x09, 0xd8, 0xb1, 0x50, 0xb4, 0x75,
+	0xac, 0xc6, 0x52, 0x36, 0x26, 0x3c, 0xec, 0xa6, 0xd6, 0xb1, 0x1a, 0xd7, 0xff, 0x96, 0x86, 0x42,
+	0xec, 0x86, 0xe8, 0x03, 0xd8, 0xea, 0xf6, 0x1f, 0xde, 0x6f, 0x1e, 0x75, 0x1f, 0x1e, 0x0e, 0xda,
+	0x9d, 0xcf, 0x9b, 0x8f, 0xee, 0x1f, 0x95, 0x53, 0x95, 0x5b, 0x4f, 0xcf, 0x6a, 0xdb, 0xf3, 0x17,
+	0x2f, 0x82, 0xb7, 0xe9, 0x31, 0x99, 0xba, 0x62, 0x91, 0xd5, 0xc3, 0x0f, 0x0f, 0x3a, 0xfd, 0x7e,
+	0x39, 0xbd, 0x8a, 0xd5, 0xe3, 0xcc, 0xa2, 0x41, 0x80, 0xf6, 0xa1, 0x3c, 0x67, 0xdd, 0x7d, 0xd2,
+	0xeb, 0xe0, 0xc7, 0xe5, 0xb5, 0xca, 0xcd, 0xa7, 0x67, 0x35, 0xf3, 0x59, 0xd2, 0xdd, 0x99, 0x4f,
+	0xf9, 0x63, 0xdd, 0xac, 0xfe, 0x23, 0x0d, 0xc5, 0x64, 0x87, 0x80, 0x0e, 0xc2, 0xbe, 0x40, 0x1d,
+	0xc0, 0xe6, 0xfe, 0xde, 0x55, 0x1d, 0x85, 0xaa, 0x32, 0xdc, 0xa9, 0xd4, 0xfb, 0x80, 0xd9, 0x14,
+	0x2b, 0x32, 0xfa, 0x00, 0x36, 0x7c, 0xc6, 0x45, 0xf4, 0x1e, 0x2f, 0x7f, 0xaa, 0x18, 0x8f, 0x4a,
+	0xb6, 0x10, 0x5c, 0x1f, 0xc3, 0xe6, 0xa2, 0x36, 0x74, 0x1b, 0xd6, 0x1f, 0x77, 0x7b, 0xe5, 0x54,
+	0xe5, 0xc6, 0xd3, 0xb3, 0xda, 0xeb, 0x8b, 0x1f, 0x1f, 0x3b, 0x5c, 0x4c, 0x89, 0xdb, 0xed, 0xa1,
+	0xf7, 0x60, 0xa3, 0x7d, 0xd8, 0xc7, 0xb8, 0x9c, 0xae, 0xec, 0x3c, 0x3d, 0xab, 0xdd, 0x58, 0xc4,
+	0xc9, 0x4f, 0x6c, 0xea, 0xd9, 0x98, 0x0d, 0xe3, 0x16, 0xfd, 0x9f, 0x6b, 0x60, 0xe8, 0x32, 0xe5,
+	0x65, 0xff, 0xc5, 0x29, 0x85, 0x25, 0x6f, 0x94, 0x5d, 0xd7, 0xae, 0xac, 0x7c, 0x8b, 0x21, 0x41,
+	0x47, 0xc6, 0x1b, 0x50, 0x74, 0xfc, 0xd3, 0x0f, 0x07, 0xd4, 0x23, 0x43, 0x57, 0x77, 0xeb, 0x79,
+	0x6c, 0x48, 0x59, 0x27, 0x14, 0xc9, 0xc2, 0xc3, 0xf1, 0x04, 0xe5, 0x9e, 0xee, 0xc3, 0xf3, 0x38,
+	0x9e, 0xa3, 0xcf, 0x20, 0xe3, 0xf8, 0x64, 0xa2, 0xcb, 0xf5, 0xa5, 0x3b, 0xe8, 0xf6, 0x9a, 0x0f,
+	0x74, 0xe4, 0xb6, 0xf2, 0x17, 0xe7, 0x3b, 0x19, 0x29, 0xc0, 0x8a, 0x26, 0x73, 0x46, 0xd8, 0x0c,
+	0xc9, 0x95, 0x54, 0xb1, 0x92, 0xc7, 0x09, 0x89, 0x8c, 0x3e, 0xc7, 0x1b, 0x71, 0x1a, 0x04, 0xaa,
+	0x6c, 0xc9, 0xe3, 0x68, 0x8a, 0x2a, 0x90, 0xd3, 0x75, 0xb7, 0x6a, 0xc1, 0x0a, 0xb2, 0x9b, 0xd1,
+	0x82, 0x56, 0x09, 0x8c, 0xf0, 0x34, 0x06, 0xc7, 0x9c, 0x4d, 0xea, 0xff, 0xca, 0x80, 0x71, 0xe0,
+	0x4e, 0x03, 0xa1, 0x6b, 0xba, 0x97, 0x76, 0xf8, 0x4f, 0x60, 0x8b, 0xa8, 0xbf, 0x42, 0xc4, 0x93,
+	0x45, 0x80, 0x6a, 0x67, 0xf4, 0x05, 0xdc, 0x5e, 0xaa, 0x2e, 0x06, 0x87, 0xad, 0x4f, 0x2b, 0x2b,
+	0x75, 0x9a, 0x69, 0x5c, 0x26, 0x97, 0xbe, 0xa0, 0x3e, 0x94, 0x18, 0xb7, 0xc6, 0x34, 0x10, 0x61,
+	0xe9, 0xa0, 0xff, 0xa2, 0x2c, 0xfd, 0xbf, 0xf6, 0x30, 0x09, 0xd4, 0x2f, 0x66, 0x68, 0xed, 0xa2,
+	0x0e, 0xf4, 0x11, 0x64, 0x38, 0x39, 0x8e, 0x5a, 0xb3, 0xa5, 0x41, 0x82, 0xc9, 0xb1, 0x58, 0x50,
+	0xa1, 0x18, 0xe8, 0x0b, 0x00, 0xdb, 0x09, 0x7c, 0x22, 0xac, 0x31, 0xe5, 0xfa, 0xb2, 0x97, 0x6e,
+	0xb1, 0x1d, 0xa3, 0x16, 0xb4, 0x24, 0xd8, 0xe8, 0x1e, 0x14, 0x2c, 0x12, 0xb9, 0x6b, 0x76, 0xf5,
+	0xaf, 0xa5, 0x83, 0xa6, 0x56, 0x51, 0x96, 0x2a, 0x2e, 0xce, 0x77, 0xf2, 0x91, 0x04, 0xe7, 0x2d,
+	0xa2, 0xdd, 0xf7, 0x1e, 0x94, 0x04, 0x09, 0x4e, 0x06, 0x76, 0x98, 0xce, 0x42, 0x37, 0x59, 0x51,
+	0x01, 0xc8, 0x0e, 0x5e, 0xa7, 0xbd, 0xe8, 0x3a, 0x8b, 0x22, 0x21, 0x43, 0xbf, 0x82, 0x2d, 0xea,
+	0x59, 0x7c, 0xa6, 0x9c, 0x35, 0xb2, 0x30, 0xbf, 0x7a, 0xb3, 0x9d, 0x18, 0xbc, 0xb0, 0xd9, 0x32,
+	0xbd, 0x24, 0xaf, 0xff, 0x3d, 0x0d, 0x10, 0x96, 0x5c, 0x2f, 0xd7, 0x01, 0x11, 0x64, 0x6c, 0x22,
+	0x88, 0xf2, 0xb9, 0x22, 0x56, 0x63, 0xf4, 0x09, 0x80, 0xa0, 0x13, 0x5f, 0xa6, 0x5e, 0x6f, 0xa4,
+	0xdd, 0xe6, 0x79, 0xe9, 0x20, 0x81, 0x46, 0xfb, 0x90, 0xd5, 0x0d, 0x74, 0xe6, 0x4a, 0x9e, 0x46,
+	0xd6, 0xff, 0x9c, 0x06, 0x08, 0xb7, 0xf9, 0x3f, 0xbd, 0xb7, 0xd6, 0xed, 0x6f, 0x7e, 0xa8, 0xa6,
+	0xbe, 0xfb, 0xa1, 0x9a, 0xfa, 0xfd, 0x45, 0x35, 0xfd, 0xcd, 0x45, 0x35, 0xfd, 0xed, 0x45, 0x35,
+	0xfd, 0xfd, 0x45, 0x35, 0xfd, 0xc7, 0x1f, 0xab, 0xa9, 0x6f, 0x7f, 0xac, 0xa6, 0xbe, 0xfb, 0xb1,
+	0x9a, 0x1a, 0x66, 0x55, 0xd1, 0xfe, 0x93, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xf9, 0x34, 0x7f,
+	0x94, 0x51, 0x18, 0x00, 0x00,
 }
 
 func (m *NodeSpec) Copy() *NodeSpec {
@@ -1604,7 +1711,7 @@ func (m *NodeSpec) CopyFrom(src interface{}) {
 
 	o := src.(*NodeSpec)
 	*m = *o
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
 }
 
 func (m *ServiceSpec) Copy() *ServiceSpec {
@@ -1620,27 +1727,27 @@ func (m *ServiceSpec) CopyFrom(src interface{}) {
 
 	o := src.(*ServiceSpec)
 	*m = *o
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Task, &o.Task)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Task, &o.Task)
 	if o.Update != nil {
 		m.Update = &UpdateConfig{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Update, o.Update)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Update, o.Update)
 	}
 	if o.Rollback != nil {
 		m.Rollback = &UpdateConfig{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Rollback, o.Rollback)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Rollback, o.Rollback)
 	}
 	if o.Networks != nil {
 		m.Networks = make([]*NetworkAttachmentConfig, len(o.Networks))
 		for i := range m.Networks {
 			m.Networks[i] = &NetworkAttachmentConfig{}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Networks[i], o.Networks[i])
+			github_com_docker_swarmkit_api_deepcopy.Copy(m.Networks[i], o.Networks[i])
 		}
 	}
 
 	if o.Endpoint != nil {
 		m.Endpoint = &EndpointSpec{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Endpoint, o.Endpoint)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Endpoint, o.Endpoint)
 	}
 	if o.Mode != nil {
 		switch o.Mode.(type) {
@@ -1648,25 +1755,25 @@ func (m *ServiceSpec) CopyFrom(src interface{}) {
 			v := ServiceSpec_Replicated{
 				Replicated: &ReplicatedService{},
 			}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(v.Replicated, o.GetReplicated())
+			github_com_docker_swarmkit_api_deepcopy.Copy(v.Replicated, o.GetReplicated())
 			m.Mode = &v
 		case *ServiceSpec_Global:
 			v := ServiceSpec_Global{
 				Global: &GlobalService{},
 			}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(v.Global, o.GetGlobal())
+			github_com_docker_swarmkit_api_deepcopy.Copy(v.Global, o.GetGlobal())
 			m.Mode = &v
 		case *ServiceSpec_ReplicatedJob:
 			v := ServiceSpec_ReplicatedJob{
 				ReplicatedJob: &ReplicatedJob{},
 			}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(v.ReplicatedJob, o.GetReplicatedJob())
+			github_com_docker_swarmkit_api_deepcopy.Copy(v.ReplicatedJob, o.GetReplicatedJob())
 			m.Mode = &v
 		case *ServiceSpec_GlobalJob:
 			v := ServiceSpec_GlobalJob{
 				GlobalJob: &GlobalJob{},
 			}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(v.GlobalJob, o.GetGlobalJob())
+			github_com_docker_swarmkit_api_deepcopy.Copy(v.GlobalJob, o.GetGlobalJob())
 			m.Mode = &v
 		}
 	}
@@ -1738,32 +1845,32 @@ func (m *TaskSpec) CopyFrom(src interface{}) {
 	*m = *o
 	if o.Resources != nil {
 		m.Resources = &ResourceRequirements{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Resources, o.Resources)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Resources, o.Resources)
 	}
 	if o.Restart != nil {
 		m.Restart = &RestartPolicy{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Restart, o.Restart)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Restart, o.Restart)
 	}
 	if o.Placement != nil {
 		m.Placement = &Placement{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Placement, o.Placement)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Placement, o.Placement)
 	}
 	if o.LogDriver != nil {
 		m.LogDriver = &Driver{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.LogDriver, o.LogDriver)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.LogDriver, o.LogDriver)
 	}
 	if o.Networks != nil {
 		m.Networks = make([]*NetworkAttachmentConfig, len(o.Networks))
 		for i := range m.Networks {
 			m.Networks[i] = &NetworkAttachmentConfig{}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Networks[i], o.Networks[i])
+			github_com_docker_swarmkit_api_deepcopy.Copy(m.Networks[i], o.Networks[i])
 		}
 	}
 
 	if o.ResourceReferences != nil {
 		m.ResourceReferences = make([]ResourceReference, len(o.ResourceReferences))
 		for i := range m.ResourceReferences {
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.ResourceReferences[i], &o.ResourceReferences[i])
+			github_com_docker_swarmkit_api_deepcopy.Copy(&m.ResourceReferences[i], &o.ResourceReferences[i])
 		}
 	}
 
@@ -1773,19 +1880,19 @@ func (m *TaskSpec) CopyFrom(src interface{}) {
 			v := TaskSpec_Attachment{
 				Attachment: &NetworkAttachmentSpec{},
 			}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(v.Attachment, o.GetAttachment())
+			github_com_docker_swarmkit_api_deepcopy.Copy(v.Attachment, o.GetAttachment())
 			m.Runtime = &v
 		case *TaskSpec_Container:
 			v := TaskSpec_Container{
 				Container: &ContainerSpec{},
 			}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(v.Container, o.GetContainer())
+			github_com_docker_swarmkit_api_deepcopy.Copy(v.Container, o.GetContainer())
 			m.Runtime = &v
 		case *TaskSpec_Generic:
 			v := TaskSpec_Generic{
 				Generic: &GenericRuntimeSpec{},
 			}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(v.Generic, o.GetGeneric())
+			github_com_docker_swarmkit_api_deepcopy.Copy(v.Generic, o.GetGeneric())
 			m.Runtime = &v
 		}
 	}
@@ -1822,7 +1929,7 @@ func (m *GenericRuntimeSpec) CopyFrom(src interface{}) {
 	*m = *o
 	if o.Payload != nil {
 		m.Payload = &types.Any{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Payload, o.Payload)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Payload, o.Payload)
 	}
 }
 
@@ -1883,32 +1990,32 @@ func (m *ContainerSpec) CopyFrom(src interface{}) {
 
 	if o.Privileges != nil {
 		m.Privileges = &Privileges{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Privileges, o.Privileges)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Privileges, o.Privileges)
 	}
 	if o.Init != nil {
 		m.Init = &types.BoolValue{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Init, o.Init)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Init, o.Init)
 	}
 	if o.Mounts != nil {
 		m.Mounts = make([]Mount, len(o.Mounts))
 		for i := range m.Mounts {
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Mounts[i], &o.Mounts[i])
+			github_com_docker_swarmkit_api_deepcopy.Copy(&m.Mounts[i], &o.Mounts[i])
 		}
 	}
 
 	if o.StopGracePeriod != nil {
 		m.StopGracePeriod = &types.Duration{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.StopGracePeriod, o.StopGracePeriod)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.StopGracePeriod, o.StopGracePeriod)
 	}
 	if o.PullOptions != nil {
 		m.PullOptions = &ContainerSpec_PullOptions{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.PullOptions, o.PullOptions)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.PullOptions, o.PullOptions)
 	}
 	if o.Secrets != nil {
 		m.Secrets = make([]*SecretReference, len(o.Secrets))
 		for i := range m.Secrets {
 			m.Secrets[i] = &SecretReference{}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Secrets[i], o.Secrets[i])
+			github_com_docker_swarmkit_api_deepcopy.Copy(m.Secrets[i], o.Secrets[i])
 		}
 	}
 
@@ -1916,7 +2023,7 @@ func (m *ContainerSpec) CopyFrom(src interface{}) {
 		m.Configs = make([]*ConfigReference, len(o.Configs))
 		for i := range m.Configs {
 			m.Configs[i] = &ConfigReference{}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Configs[i], o.Configs[i])
+			github_com_docker_swarmkit_api_deepcopy.Copy(m.Configs[i], o.Configs[i])
 		}
 	}
 
@@ -1927,11 +2034,11 @@ func (m *ContainerSpec) CopyFrom(src interface{}) {
 
 	if o.DNSConfig != nil {
 		m.DNSConfig = &ContainerSpec_DNSConfig{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.DNSConfig, o.DNSConfig)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.DNSConfig, o.DNSConfig)
 	}
 	if o.Healthcheck != nil {
 		m.Healthcheck = &HealthConfig{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Healthcheck, o.Healthcheck)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Healthcheck, o.Healthcheck)
 	}
 	if o.Sysctls != nil {
 		m.Sysctls = make(map[string]string, len(o.Sysctls))
@@ -1954,7 +2061,7 @@ func (m *ContainerSpec) CopyFrom(src interface{}) {
 		m.Ulimits = make([]*ContainerSpec_Ulimit, len(o.Ulimits))
 		for i := range m.Ulimits {
 			m.Ulimits[i] = &ContainerSpec_Ulimit{}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Ulimits[i], o.Ulimits[i])
+			github_com_docker_swarmkit_api_deepcopy.Copy(m.Ulimits[i], o.Ulimits[i])
 		}
 	}
 
@@ -2037,7 +2144,7 @@ func (m *EndpointSpec) CopyFrom(src interface{}) {
 		m.Ports = make([]*PortConfig, len(o.Ports))
 		for i := range m.Ports {
 			m.Ports[i] = &PortConfig{}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Ports[i], o.Ports[i])
+			github_com_docker_swarmkit_api_deepcopy.Copy(m.Ports[i], o.Ports[i])
 		}
 	}
 
@@ -2056,14 +2163,14 @@ func (m *NetworkSpec) CopyFrom(src interface{}) {
 
 	o := src.(*NetworkSpec)
 	*m = *o
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
 	if o.DriverConfig != nil {
 		m.DriverConfig = &Driver{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.DriverConfig, o.DriverConfig)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.DriverConfig, o.DriverConfig)
 	}
 	if o.IPAM != nil {
 		m.IPAM = &IPAMOptions{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.IPAM, o.IPAM)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.IPAM, o.IPAM)
 	}
 	if o.ConfigFrom != nil {
 		switch o.ConfigFrom.(type) {
@@ -2090,14 +2197,14 @@ func (m *ClusterSpec) CopyFrom(src interface{}) {
 
 	o := src.(*ClusterSpec)
 	*m = *o
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.AcceptancePolicy, &o.AcceptancePolicy)
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Orchestration, &o.Orchestration)
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Raft, &o.Raft)
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Dispatcher, &o.Dispatcher)
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.CAConfig, &o.CAConfig)
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.TaskDefaults, &o.TaskDefaults)
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.EncryptionConfig, &o.EncryptionConfig)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.AcceptancePolicy, &o.AcceptancePolicy)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Orchestration, &o.Orchestration)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Raft, &o.Raft)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Dispatcher, &o.Dispatcher)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.CAConfig, &o.CAConfig)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.TaskDefaults, &o.TaskDefaults)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.EncryptionConfig, &o.EncryptionConfig)
 }
 
 func (m *SecretSpec) Copy() *SecretSpec {
@@ -2113,18 +2220,18 @@ func (m *SecretSpec) CopyFrom(src interface{}) {
 
 	o := src.(*SecretSpec)
 	*m = *o
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
 	if o.Data != nil {
 		m.Data = make([]byte, len(o.Data))
 		copy(m.Data, o.Data)
 	}
 	if o.Templating != nil {
 		m.Templating = &Driver{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Templating, o.Templating)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Templating, o.Templating)
 	}
 	if o.Driver != nil {
 		m.Driver = &Driver{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Driver, o.Driver)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Driver, o.Driver)
 	}
 }
 
@@ -2141,61 +2248,21 @@ func (m *ConfigSpec) CopyFrom(src interface{}) {
 
 	o := src.(*ConfigSpec)
 	*m = *o
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
+	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
 	if o.Data != nil {
 		m.Data = make([]byte, len(o.Data))
 		copy(m.Data, o.Data)
 	}
 	if o.Templating != nil {
 		m.Templating = &Driver{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Templating, o.Templating)
-	}
-}
-
-func (m *VolumeSpec) Copy() *VolumeSpec {
-	if m == nil {
-		return nil
-	}
-	o := &VolumeSpec{}
-	o.CopyFrom(m)
-	return o
-}
-
-func (m *VolumeSpec) CopyFrom(src interface{}) {
-
-	o := src.(*VolumeSpec)
-	*m = *o
-	github_com_moby_swarmkit_v2_api_deepcopy.Copy(&m.Annotations, &o.Annotations)
-	if o.Driver != nil {
-		m.Driver = &Driver{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Driver, o.Driver)
-	}
-	if o.AccessMode != nil {
-		m.AccessMode = &VolumeAccessMode{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.AccessMode, o.AccessMode)
-	}
-	if o.Secrets != nil {
-		m.Secrets = make([]*VolumeSecret, len(o.Secrets))
-		for i := range m.Secrets {
-			m.Secrets[i] = &VolumeSecret{}
-			github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.Secrets[i], o.Secrets[i])
-		}
-	}
-
-	if o.AccessibilityRequirements != nil {
-		m.AccessibilityRequirements = &TopologyRequirement{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.AccessibilityRequirements, o.AccessibilityRequirements)
-	}
-	if o.CapacityRange != nil {
-		m.CapacityRange = &CapacityRange{}
-		github_com_moby_swarmkit_v2_api_deepcopy.Copy(m.CapacityRange, o.CapacityRange)
+		github_com_docker_swarmkit_api_deepcopy.Copy(m.Templating, o.Templating)
 	}
 }
 
 func (m *NodeSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2203,47 +2270,40 @@ func (m *NodeSpec) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *NodeSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *NodeSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.Availability != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.Availability))
-		i--
-		dAtA[i] = 0x20
-	}
-	if m.Membership != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.Membership))
-		i--
-		dAtA[i] = 0x18
+	dAtA[i] = 0xa
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
+	n1, err := m.Annotations.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
+	i += n1
 	if m.DesiredRole != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.DesiredRole))
-		i--
 		dAtA[i] = 0x10
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.DesiredRole))
 	}
-	{
-		size, err := m.Annotations.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+	if m.Membership != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Membership))
 	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
+	if m.Availability != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Availability))
+	}
+	return i, nil
 }
 
 func (m *ServiceSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2251,185 +2311,138 @@ func (m *ServiceSpec) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ServiceSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ServiceSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.Mode != nil {
-		{
-			size := m.Mode.Size()
-			i -= size
-			if _, err := m.Mode.MarshalTo(dAtA[i:]); err != nil {
-				return 0, err
-			}
-		}
+	dAtA[i] = 0xa
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
+	n2, err := m.Annotations.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
-	if m.Rollback != nil {
-		{
-			size, err := m.Rollback.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
+	i += n2
+	dAtA[i] = 0x12
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Task.Size()))
+	n3, err := m.Task.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
+	}
+	i += n3
+	if m.Mode != nil {
+		nn4, err := m.Mode.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
-		i--
-		dAtA[i] = 0x4a
+		i += nn4
 	}
-	if m.Endpoint != nil {
-		{
-			size, err := m.Endpoint.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
+	if m.Update != nil {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Update.Size()))
+		n5, err := m.Update.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
-		i--
-		dAtA[i] = 0x42
+		i += n5
 	}
 	if len(m.Networks) > 0 {
-		for iNdEx := len(m.Networks) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Networks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintSpecs(dAtA, i, uint64(size))
-			}
-			i--
+		for _, msg := range m.Networks {
 			dAtA[i] = 0x3a
-		}
-	}
-	if m.Update != nil {
-		{
-			size, err := m.Update.MarshalToSizedBuffer(dAtA[:i])
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
 			if err != nil {
 				return 0, err
 			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
+			i += n
 		}
-		i--
-		dAtA[i] = 0x32
 	}
-	{
-		size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
+	if m.Endpoint != nil {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Endpoint.Size()))
+		n6, err := m.Endpoint.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+		i += n6
 	}
-	i--
-	dAtA[i] = 0x12
-	{
-		size, err := m.Annotations.MarshalToSizedBuffer(dAtA[:i])
+	if m.Rollback != nil {
+		dAtA[i] = 0x4a
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Rollback.Size()))
+		n7, err := m.Rollback.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+		i += n7
 	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *ServiceSpec_Replicated) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ServiceSpec_Replicated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	i := 0
 	if m.Replicated != nil {
-		{
-			size, err := m.Replicated.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Replicated.Size()))
+		n8, err := m.Replicated.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n8
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 func (m *ServiceSpec_Global) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ServiceSpec_Global) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	i := 0
 	if m.Global != nil {
-		{
-			size, err := m.Global.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x22
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Global.Size()))
+		n9, err := m.Global.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n9
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 func (m *ServiceSpec_ReplicatedJob) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ServiceSpec_ReplicatedJob) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	i := 0
 	if m.ReplicatedJob != nil {
-		{
-			size, err := m.ReplicatedJob.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x52
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.ReplicatedJob.Size()))
+		n10, err := m.ReplicatedJob.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n10
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 func (m *ServiceSpec_GlobalJob) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ServiceSpec_GlobalJob) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	i := 0
 	if m.GlobalJob != nil {
-		{
-			size, err := m.GlobalJob.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x5a
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.GlobalJob.Size()))
+		n11, err := m.GlobalJob.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n11
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 func (m *ReplicatedService) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2437,27 +2450,22 @@ func (m *ReplicatedService) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ReplicatedService) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ReplicatedService) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
 	if m.Replicas != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.Replicas))
-		i--
 		dAtA[i] = 0x8
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Replicas))
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *GlobalService) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2465,22 +2473,17 @@ func (m *GlobalService) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *GlobalService) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GlobalService) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *ReplicatedJob) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2488,32 +2491,27 @@ func (m *ReplicatedJob) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ReplicatedJob) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ReplicatedJob) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.TotalCompletions != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.TotalCompletions))
-		i--
-		dAtA[i] = 0x10
-	}
 	if m.MaxConcurrent != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.MaxConcurrent))
-		i--
 		dAtA[i] = 0x8
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.MaxConcurrent))
+	}
+	if m.TotalCompletions != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.TotalCompletions))
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *GlobalJob) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2521,22 +2519,17 @@ func (m *GlobalJob) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *GlobalJob) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GlobalJob) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *TaskSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2544,175 +2537,135 @@ func (m *TaskSpec) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *TaskSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TaskSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if len(m.ResourceReferences) > 0 {
-		for iNdEx := len(m.ResourceReferences) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ResourceReferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintSpecs(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x5a
-		}
-	}
 	if m.Runtime != nil {
-		{
-			size := m.Runtime.Size()
-			i -= size
-			if _, err := m.Runtime.MarshalTo(dAtA[i:]); err != nil {
-				return 0, err
-			}
+		nn12, err := m.Runtime.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
+		i += nn12
 	}
-	if m.ForceUpdate != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.ForceUpdate))
-		i--
-		dAtA[i] = 0x48
-	}
-	if len(m.Networks) > 0 {
-		for iNdEx := len(m.Networks) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Networks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintSpecs(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x3a
+	if m.Resources != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Resources.Size()))
+		n13, err := m.Resources.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
+		i += n13
 	}
-	if m.LogDriver != nil {
-		{
-			size, err := m.LogDriver.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
+	if m.Restart != nil {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Restart.Size()))
+		n14, err := m.Restart.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
-		i--
-		dAtA[i] = 0x32
+		i += n14
 	}
 	if m.Placement != nil {
-		{
-			size, err := m.Placement.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Placement.Size()))
+		n15, err := m.Placement.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n15
 	}
-	if m.Restart != nil {
-		{
-			size, err := m.Restart.MarshalToSizedBuffer(dAtA[:i])
+	if m.LogDriver != nil {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.LogDriver.Size()))
+		n16, err := m.LogDriver.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n16
+	}
+	if len(m.Networks) > 0 {
+		for _, msg := range m.Networks {
+			dAtA[i] = 0x3a
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
 			if err != nil {
 				return 0, err
 			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
+			i += n
 		}
-		i--
-		dAtA[i] = 0x22
 	}
-	if m.Resources != nil {
-		{
-			size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i])
+	if m.ForceUpdate != 0 {
+		dAtA[i] = 0x48
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.ForceUpdate))
+	}
+	if len(m.ResourceReferences) > 0 {
+		for _, msg := range m.ResourceReferences {
+			dAtA[i] = 0x5a
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
 			if err != nil {
 				return 0, err
 			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
+			i += n
 		}
-		i--
-		dAtA[i] = 0x12
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *TaskSpec_Container) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TaskSpec_Container) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	i := 0
 	if m.Container != nil {
-		{
-			size, err := m.Container.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0xa
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Container.Size()))
+		n17, err := m.Container.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n17
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 func (m *TaskSpec_Attachment) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TaskSpec_Attachment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	i := 0
 	if m.Attachment != nil {
-		{
-			size, err := m.Attachment.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x42
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Attachment.Size()))
+		n18, err := m.Attachment.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n18
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 func (m *TaskSpec_Generic) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TaskSpec_Generic) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	i := 0
 	if m.Generic != nil {
-		{
-			size, err := m.Generic.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x52
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Generic.Size()))
+		n19, err := m.Generic.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n19
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 func (m *ResourceReference) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2720,34 +2673,28 @@ func (m *ResourceReference) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ResourceReference) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ResourceReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.ResourceType != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.ResourceType))
-		i--
-		dAtA[i] = 0x10
-	}
 	if len(m.ResourceID) > 0 {
-		i -= len(m.ResourceID)
-		copy(dAtA[i:], m.ResourceID)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.ResourceID)))
-		i--
 		dAtA[i] = 0xa
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.ResourceID)))
+		i += copy(dAtA[i:], m.ResourceID)
+	}
+	if m.ResourceType != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.ResourceType))
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *GenericRuntimeSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2755,41 +2702,33 @@ func (m *GenericRuntimeSpec) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *GenericRuntimeSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *GenericRuntimeSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.Payload != nil {
-		{
-			size, err := m.Payload.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x12
-	}
 	if len(m.Kind) > 0 {
-		i -= len(m.Kind)
-		copy(dAtA[i:], m.Kind)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Kind)))
-		i--
 		dAtA[i] = 0xa
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Kind)))
+		i += copy(dAtA[i:], m.Kind)
+	}
+	if m.Payload != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Payload.Size()))
+		n20, err := m.Payload.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n20
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *NetworkAttachmentSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2797,29 +2736,23 @@ func (m *NetworkAttachmentSpec) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *NetworkAttachmentSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *NetworkAttachmentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
 	if len(m.ContainerID) > 0 {
-		i -= len(m.ContainerID)
-		copy(dAtA[i:], m.ContainerID)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.ContainerID)))
-		i--
 		dAtA[i] = 0xa
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.ContainerID)))
+		i += copy(dAtA[i:], m.ContainerID)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *ContainerSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -2827,354 +2760,374 @@ func (m *ContainerSpec) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ContainerSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ContainerSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if len(m.Ulimits) > 0 {
-		for iNdEx := len(m.Ulimits) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Ulimits[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintSpecs(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x1
-			i--
-			dAtA[i] = 0xea
+	if len(m.Image) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Image)))
+		i += copy(dAtA[i:], m.Image)
+	}
+	if len(m.Labels) > 0 {
+		for k, _ := range m.Labels {
+			dAtA[i] = 0x12
+			i++
+			v := m.Labels[k]
+			mapSize := 1 + len(k) + sovSpecs(uint64(len(k))) + 1 + len(v) + sovSpecs(uint64(len(v)))
+			i = encodeVarintSpecs(dAtA, i, uint64(mapSize))
+			dAtA[i] = 0xa
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(len(k)))
+			i += copy(dAtA[i:], k)
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(len(v)))
+			i += copy(dAtA[i:], v)
 		}
 	}
-	if len(m.CapabilityDrop) > 0 {
-		for iNdEx := len(m.CapabilityDrop) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.CapabilityDrop[iNdEx])
-			copy(dAtA[i:], m.CapabilityDrop[iNdEx])
-			i = encodeVarintSpecs(dAtA, i, uint64(len(m.CapabilityDrop[iNdEx])))
-			i--
-			dAtA[i] = 0x1
-			i--
-			dAtA[i] = 0xe2
+	if len(m.Command) > 0 {
+		for _, s := range m.Command {
+			dAtA[i] = 0x1a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
 	}
-	if len(m.CapabilityAdd) > 0 {
-		for iNdEx := len(m.CapabilityAdd) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.CapabilityAdd[iNdEx])
-			copy(dAtA[i:], m.CapabilityAdd[iNdEx])
-			i = encodeVarintSpecs(dAtA, i, uint64(len(m.CapabilityAdd[iNdEx])))
-			i--
-			dAtA[i] = 0x1
-			i--
-			dAtA[i] = 0xda
+	if len(m.Args) > 0 {
+		for _, s := range m.Args {
+			dAtA[i] = 0x22
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
 	}
-	if len(m.Sysctls) > 0 {
-		for k := range m.Sysctls {
-			v := m.Sysctls[k]
-			baseI := i
-			i -= len(v)
-			copy(dAtA[i:], v)
-			i = encodeVarintSpecs(dAtA, i, uint64(len(v)))
-			i--
-			dAtA[i] = 0x12
-			i -= len(k)
-			copy(dAtA[i:], k)
-			i = encodeVarintSpecs(dAtA, i, uint64(len(k)))
-			i--
-			dAtA[i] = 0xa
-			i = encodeVarintSpecs(dAtA, i, uint64(baseI-i))
-			i--
-			dAtA[i] = 0x1
-			i--
-			dAtA[i] = 0xd2
+	if len(m.Env) > 0 {
+		for _, s := range m.Env {
+			dAtA[i] = 0x2a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
 	}
-	if m.PidsLimit != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.PidsLimit))
-		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0xc8
+	if len(m.Dir) > 0 {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Dir)))
+		i += copy(dAtA[i:], m.Dir)
 	}
-	if m.Isolation != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.Isolation))
-		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0xc0
+	if len(m.User) > 0 {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.User)))
+		i += copy(dAtA[i:], m.User)
 	}
-	if m.Init != nil {
-		{
-			size, err := m.Init.MarshalToSizedBuffer(dAtA[:i])
+	if len(m.Mounts) > 0 {
+		for _, msg := range m.Mounts {
+			dAtA[i] = 0x42
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
 			if err != nil {
 				return 0, err
 			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
+			i += n
 		}
-		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0xba
 	}
-	if m.Privileges != nil {
-		{
-			size, err := m.Privileges.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
+	if m.StopGracePeriod != nil {
+		dAtA[i] = 0x4a
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.StopGracePeriod.Size()))
+		n21, err := m.StopGracePeriod.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
-		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0xb2
+		i += n21
 	}
-	if len(m.Configs) > 0 {
-		for iNdEx := len(m.Configs) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Configs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintSpecs(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x1
-			i--
-			dAtA[i] = 0xaa
+	if m.PullOptions != nil {
+		dAtA[i] = 0x52
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.PullOptions.Size()))
+		n22, err := m.PullOptions.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
+		i += n22
 	}
-	if len(m.StopSignal) > 0 {
-		i -= len(m.StopSignal)
-		copy(dAtA[i:], m.StopSignal)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.StopSignal)))
-		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0xa2
+	if len(m.Groups) > 0 {
+		for _, s := range m.Groups {
+			dAtA[i] = 0x5a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
 	}
-	if m.ReadOnly {
-		i--
-		if m.ReadOnly {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
+	if len(m.Secrets) > 0 {
+		for _, msg := range m.Secrets {
+			dAtA[i] = 0x62
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
-		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0x98
 	}
-	if m.OpenStdin {
-		i--
-		if m.OpenStdin {
+	if m.TTY {
+		dAtA[i] = 0x68
+		i++
+		if m.TTY {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x1
-		i--
-		dAtA[i] = 0x90
+		i++
 	}
-	if len(m.Hosts) > 0 {
-		for iNdEx := len(m.Hosts) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Hosts[iNdEx])
-			copy(dAtA[i:], m.Hosts[iNdEx])
-			i = encodeVarintSpecs(dAtA, i, uint64(len(m.Hosts[iNdEx])))
-			i--
-			dAtA[i] = 0x1
-			i--
-			dAtA[i] = 0x8a
+	if len(m.Hostname) > 0 {
+		dAtA[i] = 0x72
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Hostname)))
+		i += copy(dAtA[i:], m.Hostname)
+	}
+	if m.DNSConfig != nil {
+		dAtA[i] = 0x7a
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.DNSConfig.Size()))
+		n23, err := m.DNSConfig.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
+		i += n23
 	}
 	if m.Healthcheck != nil {
-		{
-			size, err := m.Healthcheck.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1
-		i--
 		dAtA[i] = 0x82
+		i++
+		dAtA[i] = 0x1
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Healthcheck.Size()))
+		n24, err := m.Healthcheck.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n24
 	}
-	if m.DNSConfig != nil {
-		{
-			size, err := m.DNSConfig.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
+	if len(m.Hosts) > 0 {
+		for _, s := range m.Hosts {
+			dAtA[i] = 0x8a
+			i++
+			dAtA[i] = 0x1
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
 			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
-		i--
-		dAtA[i] = 0x7a
 	}
-	if len(m.Hostname) > 0 {
-		i -= len(m.Hostname)
-		copy(dAtA[i:], m.Hostname)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Hostname)))
-		i--
-		dAtA[i] = 0x72
-	}
-	if m.TTY {
-		i--
-		if m.TTY {
+	if m.OpenStdin {
+		dAtA[i] = 0x90
+		i++
+		dAtA[i] = 0x1
+		i++
+		if m.OpenStdin {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x68
+		i++
 	}
-	if len(m.Secrets) > 0 {
-		for iNdEx := len(m.Secrets) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Secrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintSpecs(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x62
+	if m.ReadOnly {
+		dAtA[i] = 0x98
+		i++
+		dAtA[i] = 0x1
+		i++
+		if m.ReadOnly {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
 		}
+		i++
 	}
-	if len(m.Groups) > 0 {
-		for iNdEx := len(m.Groups) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Groups[iNdEx])
-			copy(dAtA[i:], m.Groups[iNdEx])
-			i = encodeVarintSpecs(dAtA, i, uint64(len(m.Groups[iNdEx])))
-			i--
-			dAtA[i] = 0x5a
-		}
+	if len(m.StopSignal) > 0 {
+		dAtA[i] = 0xa2
+		i++
+		dAtA[i] = 0x1
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.StopSignal)))
+		i += copy(dAtA[i:], m.StopSignal)
 	}
-	if m.PullOptions != nil {
-		{
-			size, err := m.PullOptions.MarshalToSizedBuffer(dAtA[:i])
+	if len(m.Configs) > 0 {
+		for _, msg := range m.Configs {
+			dAtA[i] = 0xaa
+			i++
+			dAtA[i] = 0x1
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
 			if err != nil {
 				return 0, err
 			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
+			i += n
 		}
-		i--
-		dAtA[i] = 0x52
 	}
-	if m.StopGracePeriod != nil {
-		{
-			size, err := m.StopGracePeriod.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
+	if m.Privileges != nil {
+		dAtA[i] = 0xb2
+		i++
+		dAtA[i] = 0x1
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Privileges.Size()))
+		n25, err := m.Privileges.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
-		i--
-		dAtA[i] = 0x4a
+		i += n25
 	}
-	if len(m.Mounts) > 0 {
-		for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Mounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintSpecs(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x42
+	if m.Init != nil {
+		dAtA[i] = 0xba
+		i++
+		dAtA[i] = 0x1
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Init.Size()))
+		n26, err := m.Init.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
+		i += n26
 	}
-	if len(m.User) > 0 {
-		i -= len(m.User)
-		copy(dAtA[i:], m.User)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.User)))
-		i--
-		dAtA[i] = 0x3a
+	if m.Isolation != 0 {
+		dAtA[i] = 0xc0
+		i++
+		dAtA[i] = 0x1
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Isolation))
 	}
-	if len(m.Dir) > 0 {
-		i -= len(m.Dir)
-		copy(dAtA[i:], m.Dir)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Dir)))
-		i--
-		dAtA[i] = 0x32
+	if m.PidsLimit != 0 {
+		dAtA[i] = 0xc8
+		i++
+		dAtA[i] = 0x1
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.PidsLimit))
 	}
-	if len(m.Env) > 0 {
-		for iNdEx := len(m.Env) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Env[iNdEx])
-			copy(dAtA[i:], m.Env[iNdEx])
-			i = encodeVarintSpecs(dAtA, i, uint64(len(m.Env[iNdEx])))
-			i--
-			dAtA[i] = 0x2a
+	if len(m.Sysctls) > 0 {
+		for k, _ := range m.Sysctls {
+			dAtA[i] = 0xd2
+			i++
+			dAtA[i] = 0x1
+			i++
+			v := m.Sysctls[k]
+			mapSize := 1 + len(k) + sovSpecs(uint64(len(k))) + 1 + len(v) + sovSpecs(uint64(len(v)))
+			i = encodeVarintSpecs(dAtA, i, uint64(mapSize))
+			dAtA[i] = 0xa
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(len(k)))
+			i += copy(dAtA[i:], k)
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(len(v)))
+			i += copy(dAtA[i:], v)
 		}
 	}
-	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 = encodeVarintSpecs(dAtA, i, uint64(len(m.Args[iNdEx])))
-			i--
-			dAtA[i] = 0x22
+	if len(m.CapabilityAdd) > 0 {
+		for _, s := range m.CapabilityAdd {
+			dAtA[i] = 0xda
+			i++
+			dAtA[i] = 0x1
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
 	}
-	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 = encodeVarintSpecs(dAtA, i, uint64(len(m.Command[iNdEx])))
-			i--
-			dAtA[i] = 0x1a
+	if len(m.CapabilityDrop) > 0 {
+		for _, s := range m.CapabilityDrop {
+			dAtA[i] = 0xe2
+			i++
+			dAtA[i] = 0x1
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
 	}
-	if len(m.Labels) > 0 {
-		for k := range m.Labels {
-			v := m.Labels[k]
-			baseI := i
-			i -= len(v)
-			copy(dAtA[i:], v)
-			i = encodeVarintSpecs(dAtA, i, uint64(len(v)))
-			i--
-			dAtA[i] = 0x12
-			i -= len(k)
-			copy(dAtA[i:], k)
-			i = encodeVarintSpecs(dAtA, i, uint64(len(k)))
-			i--
-			dAtA[i] = 0xa
-			i = encodeVarintSpecs(dAtA, i, uint64(baseI-i))
-			i--
-			dAtA[i] = 0x12
+	if len(m.Ulimits) > 0 {
+		for _, msg := range m.Ulimits {
+			dAtA[i] = 0xea
+			i++
+			dAtA[i] = 0x1
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
 	}
-	if len(m.Image) > 0 {
-		i -= len(m.Image)
-		copy(dAtA[i:], m.Image)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Image)))
-		i--
-		dAtA[i] = 0xa
+	if m.Privileged {
+		dAtA[i] = 0xf0
+		i++
+		dAtA[i] = 0x1
+		i++
+		if m.Privileged {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *ContainerSpec_PullOptions) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3182,31 +3135,25 @@ func (m *ContainerSpec_PullOptions) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ContainerSpec_PullOptions) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ContainerSpec_PullOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
 	if len(m.RegistryAuth) > 0 {
-		i -= len(m.RegistryAuth)
-		copy(dAtA[i:], m.RegistryAuth)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.RegistryAuth)))
-		i--
-		dAtA[i] = 0x4
-		i--
 		dAtA[i] = 0x82
+		i++
+		dAtA[i] = 0x4
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.RegistryAuth)))
+		i += copy(dAtA[i:], m.RegistryAuth)
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *ContainerSpec_DNSConfig) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3214,49 +3161,62 @@ func (m *ContainerSpec_DNSConfig) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ContainerSpec_DNSConfig) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ContainerSpec_DNSConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if len(m.Options) > 0 {
-		for iNdEx := len(m.Options) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Options[iNdEx])
-			copy(dAtA[i:], m.Options[iNdEx])
-			i = encodeVarintSpecs(dAtA, i, uint64(len(m.Options[iNdEx])))
-			i--
-			dAtA[i] = 0x1a
+	if len(m.Nameservers) > 0 {
+		for _, s := range m.Nameservers {
+			dAtA[i] = 0xa
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
 	}
 	if len(m.Search) > 0 {
-		for iNdEx := len(m.Search) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Search[iNdEx])
-			copy(dAtA[i:], m.Search[iNdEx])
-			i = encodeVarintSpecs(dAtA, i, uint64(len(m.Search[iNdEx])))
-			i--
+		for _, s := range m.Search {
 			dAtA[i] = 0x12
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
 	}
-	if len(m.Nameservers) > 0 {
-		for iNdEx := len(m.Nameservers) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.Nameservers[iNdEx])
-			copy(dAtA[i:], m.Nameservers[iNdEx])
-			i = encodeVarintSpecs(dAtA, i, uint64(len(m.Nameservers[iNdEx])))
-			i--
-			dAtA[i] = 0xa
+	if len(m.Options) > 0 {
+		for _, s := range m.Options {
+			dAtA[i] = 0x1a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
 		}
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *ContainerSpec_Ulimit) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3264,39 +3224,33 @@ func (m *ContainerSpec_Ulimit) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ContainerSpec_Ulimit) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ContainerSpec_Ulimit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.Hard != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.Hard))
-		i--
-		dAtA[i] = 0x18
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
 	}
 	if m.Soft != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.Soft))
-		i--
 		dAtA[i] = 0x10
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Soft))
 	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Name)))
-		i--
-		dAtA[i] = 0xa
+	if m.Hard != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Hard))
 	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *EndpointSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3304,41 +3258,34 @@ func (m *EndpointSpec) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *EndpointSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *EndpointSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
+	if m.Mode != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Mode))
+	}
 	if len(m.Ports) > 0 {
-		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintSpecs(dAtA, i, uint64(size))
-			}
-			i--
+		for _, msg := range m.Ports {
 			dAtA[i] = 0x12
+			i++
+			i = encodeVarintSpecs(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
 		}
 	}
-	if m.Mode != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.Mode))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *NetworkSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3346,119 +3293,100 @@ func (m *NetworkSpec) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *NetworkSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.ConfigFrom != nil {
-		{
-			size := m.ConfigFrom.Size()
-			i -= size
-			if _, err := m.ConfigFrom.MarshalTo(dAtA[i:]); err != nil {
-				return 0, err
-			}
+	dAtA[i] = 0xa
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
+	n27, err := m.Annotations.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
+	}
+	i += n27
+	if m.DriverConfig != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.DriverConfig.Size()))
+		n28, err := m.DriverConfig.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
 		}
+		i += n28
 	}
-	if m.Ingress {
-		i--
-		if m.Ingress {
+	if m.Ipv6Enabled {
+		dAtA[i] = 0x18
+		i++
+		if m.Ipv6Enabled {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x38
+		i++
 	}
-	if m.Attachable {
-		i--
-		if m.Attachable {
+	if m.Internal {
+		dAtA[i] = 0x20
+		i++
+		if m.Internal {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x30
+		i++
 	}
 	if m.IPAM != nil {
-		{
-			size, err := m.IPAM.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
 		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.IPAM.Size()))
+		n29, err := m.IPAM.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n29
 	}
-	if m.Internal {
-		i--
-		if m.Internal {
+	if m.Attachable {
+		dAtA[i] = 0x30
+		i++
+		if m.Attachable {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x20
+		i++
 	}
-	if m.Ipv6Enabled {
-		i--
-		if m.Ipv6Enabled {
+	if m.Ingress {
+		dAtA[i] = 0x38
+		i++
+		if m.Ingress {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
 		}
-		i--
-		dAtA[i] = 0x18
-	}
-	if m.DriverConfig != nil {
-		{
-			size, err := m.DriverConfig.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x12
+		i++
 	}
-	{
-		size, err := m.Annotations.MarshalToSizedBuffer(dAtA[:i])
+	if m.ConfigFrom != nil {
+		nn30, err := m.ConfigFrom.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+		i += nn30
 	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func (m *NetworkSpec_Network) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *NetworkSpec_Network) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	i -= len(m.Network)
-	copy(dAtA[i:], m.Network)
-	i = encodeVarintSpecs(dAtA, i, uint64(len(m.Network)))
-	i--
+	i := 0
 	dAtA[i] = 0x42
-	return len(dAtA) - i, nil
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(len(m.Network)))
+	i += copy(dAtA[i:], m.Network)
+	return i, nil
 }
 func (m *ClusterSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3466,102 +3394,81 @@ func (m *ClusterSpec) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *ClusterSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ClusterSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	{
-		size, err := m.EncryptionConfig.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+	dAtA[i] = 0xa
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
+	n31, err := m.Annotations.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
-	i--
-	dAtA[i] = 0x42
-	{
-		size, err := m.TaskDefaults.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+	i += n31
+	dAtA[i] = 0x12
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.AcceptancePolicy.Size()))
+	n32, err := m.AcceptancePolicy.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
-	i--
-	dAtA[i] = 0x3a
-	{
-		size, err := m.CAConfig.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+	i += n32
+	dAtA[i] = 0x1a
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Orchestration.Size()))
+	n33, err := m.Orchestration.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
-	i--
-	dAtA[i] = 0x32
-	{
-		size, err := m.Dispatcher.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+	i += n33
+	dAtA[i] = 0x22
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Raft.Size()))
+	n34, err := m.Raft.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
-	i--
+	i += n34
 	dAtA[i] = 0x2a
-	{
-		size, err := m.Raft.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Dispatcher.Size()))
+	n35, err := m.Dispatcher.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
-	i--
-	dAtA[i] = 0x22
-	{
-		size, err := m.Orchestration.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+	i += n35
+	dAtA[i] = 0x32
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.CAConfig.Size()))
+	n36, err := m.CAConfig.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
-	i--
-	dAtA[i] = 0x1a
-	{
-		size, err := m.AcceptancePolicy.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+	i += n36
+	dAtA[i] = 0x3a
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.TaskDefaults.Size()))
+	n37, err := m.TaskDefaults.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
-	i--
-	dAtA[i] = 0x12
-	{
-		size, err := m.Annotations.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+	i += n37
+	dAtA[i] = 0x42
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.EncryptionConfig.Size()))
+	n38, err := m.EncryptionConfig.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
+	i += n38
+	return i, nil
 }
 
 func (m *SecretSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
@@ -3569,228 +3476,97 @@ func (m *SecretSpec) Marshal() (dAtA []byte, err error) {
 }
 
 func (m *SecretSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *SecretSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.Driver != nil {
-		{
-			size, err := m.Driver.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x22
-	}
-	if m.Templating != nil {
-		{
-			size, err := m.Templating.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1a
+	dAtA[i] = 0xa
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
+	n39, err := m.Annotations.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
+	i += n39
 	if len(m.Data) > 0 {
-		i -= len(m.Data)
-		copy(dAtA[i:], m.Data)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Data)))
-		i--
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Data)))
+		i += copy(dAtA[i:], m.Data)
 	}
-	{
-		size, err := m.Annotations.MarshalToSizedBuffer(dAtA[:i])
+	if m.Templating != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Templating.Size()))
+		n40, err := m.Templating.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *ConfigSpec) 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 *ConfigSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ConfigSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.Templating != nil {
-		{
-			size, err := m.Templating.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1a
+		i += n40
 	}
-	if len(m.Data) > 0 {
-		i -= len(m.Data)
-		copy(dAtA[i:], m.Data)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Data)))
-		i--
-		dAtA[i] = 0x12
-	}
-	{
-		size, err := m.Annotations.MarshalToSizedBuffer(dAtA[:i])
+	if m.Driver != nil {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Driver.Size()))
+		n41, err := m.Driver.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+		i += n41
 	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
-func (m *VolumeSpec) Marshal() (dAtA []byte, err error) {
+func (m *ConfigSpec) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	n, err := m.MarshalTo(dAtA)
 	if err != nil {
 		return nil, err
 	}
 	return dAtA[:n], nil
 }
 
-func (m *VolumeSpec) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *VolumeSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
+func (m *ConfigSpec) MarshalTo(dAtA []byte) (int, error) {
+	var i int
 	_ = i
 	var l int
 	_ = l
-	if m.Availability != 0 {
-		i = encodeVarintSpecs(dAtA, i, uint64(m.Availability))
-		i--
-		dAtA[i] = 0x40
-	}
-	if m.CapacityRange != nil {
-		{
-			size, err := m.CapacityRange.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x3a
-	}
-	if m.AccessibilityRequirements != nil {
-		{
-			size, err := m.AccessibilityRequirements.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x32
-	}
-	if len(m.Secrets) > 0 {
-		for iNdEx := len(m.Secrets) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.Secrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintSpecs(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x2a
-		}
-	}
-	if m.AccessMode != nil {
-		{
-			size, err := m.AccessMode.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x22
-	}
-	if m.Driver != nil {
-		{
-			size, err := m.Driver.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintSpecs(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1a
+	dAtA[i] = 0xa
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
+	n42, err := m.Annotations.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
 	}
-	if len(m.Group) > 0 {
-		i -= len(m.Group)
-		copy(dAtA[i:], m.Group)
-		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Group)))
-		i--
+	i += n42
+	if len(m.Data) > 0 {
 		dAtA[i] = 0x12
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(len(m.Data)))
+		i += copy(dAtA[i:], m.Data)
 	}
-	{
-		size, err := m.Annotations.MarshalToSizedBuffer(dAtA[:i])
+	if m.Templating != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintSpecs(dAtA, i, uint64(m.Templating.Size()))
+		n43, err := m.Templating.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i -= size
-		i = encodeVarintSpecs(dAtA, i, uint64(size))
+		i += n43
 	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
+	return i, nil
 }
 
 func encodeVarintSpecs(dAtA []byte, offset int, v uint64) int {
-	offset -= sovSpecs(v)
-	base := offset
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
 		v >>= 7
 		offset++
 	}
 	dAtA[offset] = uint8(v)
-	return base
+	return offset + 1
 }
 func (m *NodeSpec) Size() (n int) {
 	if m == nil {
@@ -4211,6 +3987,9 @@ func (m *ContainerSpec) Size() (n int) {
 			n += 2 + l + sovSpecs(uint64(l))
 		}
 	}
+	if m.Privileged {
+		n += 3
+	}
 	return n
 }
 
@@ -4402,48 +4181,15 @@ func (m *ConfigSpec) Size() (n int) {
 	return n
 }
 
-func (m *VolumeSpec) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.Annotations.Size()
-	n += 1 + l + sovSpecs(uint64(l))
-	l = len(m.Group)
-	if l > 0 {
-		n += 1 + l + sovSpecs(uint64(l))
-	}
-	if m.Driver != nil {
-		l = m.Driver.Size()
-		n += 1 + l + sovSpecs(uint64(l))
-	}
-	if m.AccessMode != nil {
-		l = m.AccessMode.Size()
-		n += 1 + l + sovSpecs(uint64(l))
-	}
-	if len(m.Secrets) > 0 {
-		for _, e := range m.Secrets {
-			l = e.Size()
-			n += 1 + l + sovSpecs(uint64(l))
-		}
-	}
-	if m.AccessibilityRequirements != nil {
-		l = m.AccessibilityRequirements.Size()
-		n += 1 + l + sovSpecs(uint64(l))
-	}
-	if m.CapacityRange != nil {
-		l = m.CapacityRange.Size()
-		n += 1 + l + sovSpecs(uint64(l))
-	}
-	if m.Availability != 0 {
-		n += 1 + sovSpecs(uint64(m.Availability))
-	}
-	return n
-}
-
 func sovSpecs(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
 }
 func sozSpecs(x uint64) (n int) {
 	return sovSpecs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
@@ -4453,7 +4199,7 @@ func (this *NodeSpec) String() string {
 		return "nil"
 	}
 	s := strings.Join([]string{`&NodeSpec{`,
-		`Annotations:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Annotations), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
+		`Annotations:` + strings.Replace(strings.Replace(this.Annotations.String(), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
 		`DesiredRole:` + fmt.Sprintf("%v", this.DesiredRole) + `,`,
 		`Membership:` + fmt.Sprintf("%v", this.Membership) + `,`,
 		`Availability:` + fmt.Sprintf("%v", this.Availability) + `,`,
@@ -4465,18 +4211,13 @@ func (this *ServiceSpec) String() string {
 	if this == nil {
 		return "nil"
 	}
-	repeatedStringForNetworks := "[]*NetworkAttachmentConfig{"
-	for _, f := range this.Networks {
-		repeatedStringForNetworks += strings.Replace(fmt.Sprintf("%v", f), "NetworkAttachmentConfig", "NetworkAttachmentConfig", 1) + ","
-	}
-	repeatedStringForNetworks += "}"
 	s := strings.Join([]string{`&ServiceSpec{`,
-		`Annotations:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Annotations), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
+		`Annotations:` + strings.Replace(strings.Replace(this.Annotations.String(), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
 		`Task:` + strings.Replace(strings.Replace(this.Task.String(), "TaskSpec", "TaskSpec", 1), `&`, ``, 1) + `,`,
 		`Mode:` + fmt.Sprintf("%v", this.Mode) + `,`,
 		`Update:` + strings.Replace(fmt.Sprintf("%v", this.Update), "UpdateConfig", "UpdateConfig", 1) + `,`,
-		`Networks:` + repeatedStringForNetworks + `,`,
-		`Endpoint:` + strings.Replace(this.Endpoint.String(), "EndpointSpec", "EndpointSpec", 1) + `,`,
+		`Networks:` + strings.Replace(fmt.Sprintf("%v", this.Networks), "NetworkAttachmentConfig", "NetworkAttachmentConfig", 1) + `,`,
+		`Endpoint:` + strings.Replace(fmt.Sprintf("%v", this.Endpoint), "EndpointSpec", "EndpointSpec", 1) + `,`,
 		`Rollback:` + strings.Replace(fmt.Sprintf("%v", this.Rollback), "UpdateConfig", "UpdateConfig", 1) + `,`,
 		`}`,
 	}, "")
@@ -4565,25 +4306,15 @@ func (this *TaskSpec) String() string {
 	if this == nil {
 		return "nil"
 	}
-	repeatedStringForNetworks := "[]*NetworkAttachmentConfig{"
-	for _, f := range this.Networks {
-		repeatedStringForNetworks += strings.Replace(fmt.Sprintf("%v", f), "NetworkAttachmentConfig", "NetworkAttachmentConfig", 1) + ","
-	}
-	repeatedStringForNetworks += "}"
-	repeatedStringForResourceReferences := "[]ResourceReference{"
-	for _, f := range this.ResourceReferences {
-		repeatedStringForResourceReferences += strings.Replace(strings.Replace(f.String(), "ResourceReference", "ResourceReference", 1), `&`, ``, 1) + ","
-	}
-	repeatedStringForResourceReferences += "}"
 	s := strings.Join([]string{`&TaskSpec{`,
 		`Runtime:` + fmt.Sprintf("%v", this.Runtime) + `,`,
 		`Resources:` + strings.Replace(fmt.Sprintf("%v", this.Resources), "ResourceRequirements", "ResourceRequirements", 1) + `,`,
 		`Restart:` + strings.Replace(fmt.Sprintf("%v", this.Restart), "RestartPolicy", "RestartPolicy", 1) + `,`,
 		`Placement:` + strings.Replace(fmt.Sprintf("%v", this.Placement), "Placement", "Placement", 1) + `,`,
 		`LogDriver:` + strings.Replace(fmt.Sprintf("%v", this.LogDriver), "Driver", "Driver", 1) + `,`,
-		`Networks:` + repeatedStringForNetworks + `,`,
+		`Networks:` + strings.Replace(fmt.Sprintf("%v", this.Networks), "NetworkAttachmentConfig", "NetworkAttachmentConfig", 1) + `,`,
 		`ForceUpdate:` + fmt.Sprintf("%v", this.ForceUpdate) + `,`,
-		`ResourceReferences:` + repeatedStringForResourceReferences + `,`,
+		`ResourceReferences:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ResourceReferences), "ResourceReference", "ResourceReference", 1), `&`, ``, 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -4654,26 +4385,6 @@ func (this *ContainerSpec) String() string {
 	if this == nil {
 		return "nil"
 	}
-	repeatedStringForMounts := "[]Mount{"
-	for _, f := range this.Mounts {
-		repeatedStringForMounts += fmt.Sprintf("%v", f) + ","
-	}
-	repeatedStringForMounts += "}"
-	repeatedStringForSecrets := "[]*SecretReference{"
-	for _, f := range this.Secrets {
-		repeatedStringForSecrets += strings.Replace(fmt.Sprintf("%v", f), "SecretReference", "SecretReference", 1) + ","
-	}
-	repeatedStringForSecrets += "}"
-	repeatedStringForConfigs := "[]*ConfigReference{"
-	for _, f := range this.Configs {
-		repeatedStringForConfigs += strings.Replace(fmt.Sprintf("%v", f), "ConfigReference", "ConfigReference", 1) + ","
-	}
-	repeatedStringForConfigs += "}"
-	repeatedStringForUlimits := "[]*ContainerSpec_Ulimit{"
-	for _, f := range this.Ulimits {
-		repeatedStringForUlimits += strings.Replace(fmt.Sprintf("%v", f), "ContainerSpec_Ulimit", "ContainerSpec_Ulimit", 1) + ","
-	}
-	repeatedStringForUlimits += "}"
 	keysForLabels := make([]string, 0, len(this.Labels))
 	for k, _ := range this.Labels {
 		keysForLabels = append(keysForLabels, k)
@@ -4702,11 +4413,11 @@ func (this *ContainerSpec) String() string {
 		`Env:` + fmt.Sprintf("%v", this.Env) + `,`,
 		`Dir:` + fmt.Sprintf("%v", this.Dir) + `,`,
 		`User:` + fmt.Sprintf("%v", this.User) + `,`,
-		`Mounts:` + repeatedStringForMounts + `,`,
+		`Mounts:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Mounts), "Mount", "Mount", 1), `&`, ``, 1) + `,`,
 		`StopGracePeriod:` + strings.Replace(fmt.Sprintf("%v", this.StopGracePeriod), "Duration", "types.Duration", 1) + `,`,
 		`PullOptions:` + strings.Replace(fmt.Sprintf("%v", this.PullOptions), "ContainerSpec_PullOptions", "ContainerSpec_PullOptions", 1) + `,`,
 		`Groups:` + fmt.Sprintf("%v", this.Groups) + `,`,
-		`Secrets:` + repeatedStringForSecrets + `,`,
+		`Secrets:` + strings.Replace(fmt.Sprintf("%v", this.Secrets), "SecretReference", "SecretReference", 1) + `,`,
 		`TTY:` + fmt.Sprintf("%v", this.TTY) + `,`,
 		`Hostname:` + fmt.Sprintf("%v", this.Hostname) + `,`,
 		`DNSConfig:` + strings.Replace(fmt.Sprintf("%v", this.DNSConfig), "ContainerSpec_DNSConfig", "ContainerSpec_DNSConfig", 1) + `,`,
@@ -4715,7 +4426,7 @@ func (this *ContainerSpec) String() string {
 		`OpenStdin:` + fmt.Sprintf("%v", this.OpenStdin) + `,`,
 		`ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
 		`StopSignal:` + fmt.Sprintf("%v", this.StopSignal) + `,`,
-		`Configs:` + repeatedStringForConfigs + `,`,
+		`Configs:` + strings.Replace(fmt.Sprintf("%v", this.Configs), "ConfigReference", "ConfigReference", 1) + `,`,
 		`Privileges:` + strings.Replace(fmt.Sprintf("%v", this.Privileges), "Privileges", "Privileges", 1) + `,`,
 		`Init:` + strings.Replace(fmt.Sprintf("%v", this.Init), "BoolValue", "types.BoolValue", 1) + `,`,
 		`Isolation:` + fmt.Sprintf("%v", this.Isolation) + `,`,
@@ -4723,7 +4434,8 @@ func (this *ContainerSpec) String() string {
 		`Sysctls:` + mapStringForSysctls + `,`,
 		`CapabilityAdd:` + fmt.Sprintf("%v", this.CapabilityAdd) + `,`,
 		`CapabilityDrop:` + fmt.Sprintf("%v", this.CapabilityDrop) + `,`,
-		`Ulimits:` + repeatedStringForUlimits + `,`,
+		`Ulimits:` + strings.Replace(fmt.Sprintf("%v", this.Ulimits), "ContainerSpec_Ulimit", "ContainerSpec_Ulimit", 1) + `,`,
+		`Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -4766,14 +4478,9 @@ func (this *EndpointSpec) String() string {
 	if this == nil {
 		return "nil"
 	}
-	repeatedStringForPorts := "[]*PortConfig{"
-	for _, f := range this.Ports {
-		repeatedStringForPorts += strings.Replace(fmt.Sprintf("%v", f), "PortConfig", "PortConfig", 1) + ","
-	}
-	repeatedStringForPorts += "}"
 	s := strings.Join([]string{`&EndpointSpec{`,
 		`Mode:` + fmt.Sprintf("%v", this.Mode) + `,`,
-		`Ports:` + repeatedStringForPorts + `,`,
+		`Ports:` + strings.Replace(fmt.Sprintf("%v", this.Ports), "PortConfig", "PortConfig", 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -4783,7 +4490,7 @@ func (this *NetworkSpec) String() string {
 		return "nil"
 	}
 	s := strings.Join([]string{`&NetworkSpec{`,
-		`Annotations:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Annotations), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
+		`Annotations:` + strings.Replace(strings.Replace(this.Annotations.String(), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
 		`DriverConfig:` + strings.Replace(fmt.Sprintf("%v", this.DriverConfig), "Driver", "Driver", 1) + `,`,
 		`Ipv6Enabled:` + fmt.Sprintf("%v", this.Ipv6Enabled) + `,`,
 		`Internal:` + fmt.Sprintf("%v", this.Internal) + `,`,
@@ -4810,14 +4517,14 @@ func (this *ClusterSpec) String() string {
 		return "nil"
 	}
 	s := strings.Join([]string{`&ClusterSpec{`,
-		`Annotations:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Annotations), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
-		`AcceptancePolicy:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AcceptancePolicy), "AcceptancePolicy", "AcceptancePolicy", 1), `&`, ``, 1) + `,`,
-		`Orchestration:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Orchestration), "OrchestrationConfig", "OrchestrationConfig", 1), `&`, ``, 1) + `,`,
-		`Raft:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Raft), "RaftConfig", "RaftConfig", 1), `&`, ``, 1) + `,`,
-		`Dispatcher:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Dispatcher), "DispatcherConfig", "DispatcherConfig", 1), `&`, ``, 1) + `,`,
-		`CAConfig:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CAConfig), "CAConfig", "CAConfig", 1), `&`, ``, 1) + `,`,
-		`TaskDefaults:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.TaskDefaults), "TaskDefaults", "TaskDefaults", 1), `&`, ``, 1) + `,`,
-		`EncryptionConfig:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.EncryptionConfig), "EncryptionConfig", "EncryptionConfig", 1), `&`, ``, 1) + `,`,
+		`Annotations:` + strings.Replace(strings.Replace(this.Annotations.String(), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
+		`AcceptancePolicy:` + strings.Replace(strings.Replace(this.AcceptancePolicy.String(), "AcceptancePolicy", "AcceptancePolicy", 1), `&`, ``, 1) + `,`,
+		`Orchestration:` + strings.Replace(strings.Replace(this.Orchestration.String(), "OrchestrationConfig", "OrchestrationConfig", 1), `&`, ``, 1) + `,`,
+		`Raft:` + strings.Replace(strings.Replace(this.Raft.String(), "RaftConfig", "RaftConfig", 1), `&`, ``, 1) + `,`,
+		`Dispatcher:` + strings.Replace(strings.Replace(this.Dispatcher.String(), "DispatcherConfig", "DispatcherConfig", 1), `&`, ``, 1) + `,`,
+		`CAConfig:` + strings.Replace(strings.Replace(this.CAConfig.String(), "CAConfig", "CAConfig", 1), `&`, ``, 1) + `,`,
+		`TaskDefaults:` + strings.Replace(strings.Replace(this.TaskDefaults.String(), "TaskDefaults", "TaskDefaults", 1), `&`, ``, 1) + `,`,
+		`EncryptionConfig:` + strings.Replace(strings.Replace(this.EncryptionConfig.String(), "EncryptionConfig", "EncryptionConfig", 1), `&`, ``, 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -4827,7 +4534,7 @@ func (this *SecretSpec) String() string {
 		return "nil"
 	}
 	s := strings.Join([]string{`&SecretSpec{`,
-		`Annotations:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Annotations), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
+		`Annotations:` + strings.Replace(strings.Replace(this.Annotations.String(), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
 		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
 		`Templating:` + strings.Replace(fmt.Sprintf("%v", this.Templating), "Driver", "Driver", 1) + `,`,
 		`Driver:` + strings.Replace(fmt.Sprintf("%v", this.Driver), "Driver", "Driver", 1) + `,`,
@@ -4840,35 +4547,13 @@ func (this *ConfigSpec) String() string {
 		return "nil"
 	}
 	s := strings.Join([]string{`&ConfigSpec{`,
-		`Annotations:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Annotations), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
+		`Annotations:` + strings.Replace(strings.Replace(this.Annotations.String(), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
 		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
 		`Templating:` + strings.Replace(fmt.Sprintf("%v", this.Templating), "Driver", "Driver", 1) + `,`,
 		`}`,
 	}, "")
 	return s
 }
-func (this *VolumeSpec) String() string {
-	if this == nil {
-		return "nil"
-	}
-	repeatedStringForSecrets := "[]*VolumeSecret{"
-	for _, f := range this.Secrets {
-		repeatedStringForSecrets += strings.Replace(fmt.Sprintf("%v", f), "VolumeSecret", "VolumeSecret", 1) + ","
-	}
-	repeatedStringForSecrets += "}"
-	s := strings.Join([]string{`&VolumeSpec{`,
-		`Annotations:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Annotations), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`,
-		`Group:` + fmt.Sprintf("%v", this.Group) + `,`,
-		`Driver:` + strings.Replace(fmt.Sprintf("%v", this.Driver), "Driver", "Driver", 1) + `,`,
-		`AccessMode:` + strings.Replace(fmt.Sprintf("%v", this.AccessMode), "VolumeAccessMode", "VolumeAccessMode", 1) + `,`,
-		`Secrets:` + repeatedStringForSecrets + `,`,
-		`AccessibilityRequirements:` + strings.Replace(fmt.Sprintf("%v", this.AccessibilityRequirements), "TopologyRequirement", "TopologyRequirement", 1) + `,`,
-		`CapacityRange:` + strings.Replace(fmt.Sprintf("%v", this.CapacityRange), "CapacityRange", "CapacityRange", 1) + `,`,
-		`Availability:` + fmt.Sprintf("%v", this.Availability) + `,`,
-		`}`,
-	}, "")
-	return s
-}
 func valueToStringSpecs(v interface{}) string {
 	rv := reflect.ValueOf(v)
 	if rv.IsNil() {
@@ -5002,7 +4687,10 @@ func (m *NodeSpec) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -5400,7 +5088,10 @@ func (m *ServiceSpec) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -5469,7 +5160,10 @@ func (m *ReplicatedService) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -5519,7 +5213,10 @@ func (m *GlobalService) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -5607,7 +5304,10 @@ func (m *ReplicatedJob) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -5657,7 +5357,10 @@ func (m *GlobalJob) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -6043,7 +5746,10 @@ func (m *TaskSpec) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -6144,7 +5850,10 @@ func (m *ResourceReference) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -6262,7 +5971,10 @@ func (m *GenericRuntimeSpec) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -6344,7 +6056,10 @@ func (m *NetworkAttachmentSpec) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -6536,7 +6251,7 @@ func (m *ContainerSpec) Unmarshal(dAtA []byte) error {
 					if err != nil {
 						return err
 					}
-					if (skippy < 0) || (iNdEx+skippy) < 0 {
+					if skippy < 0 {
 						return ErrInvalidLengthSpecs
 					}
 					if (iNdEx + skippy) > postIndex {
@@ -7367,7 +7082,7 @@ func (m *ContainerSpec) Unmarshal(dAtA []byte) error {
 					if err != nil {
 						return err
 					}
-					if (skippy < 0) || (iNdEx+skippy) < 0 {
+					if skippy < 0 {
 						return ErrInvalidLengthSpecs
 					}
 					if (iNdEx + skippy) > postIndex {
@@ -7476,207 +7191,11 @@ func (m *ContainerSpec) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipSpecs(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *ContainerSpec_PullOptions) 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 ErrIntOverflowSpecs
-			}
-			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: PullOptions: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: PullOptions: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 64:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RegistryAuth", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSpecs
-				}
-				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 ErrInvalidLengthSpecs
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.RegistryAuth = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipSpecs(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *ContainerSpec_DNSConfig) 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 ErrIntOverflowSpecs
-			}
-			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: DNSConfig: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DNSConfig: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Nameservers", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSpecs
-				}
-				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 ErrInvalidLengthSpecs
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Nameservers = append(m.Nameservers, string(dAtA[iNdEx:postIndex]))
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Search", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSpecs
-				}
-				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 ErrInvalidLengthSpecs
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Search = append(m.Search, string(dAtA[iNdEx:postIndex]))
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
+		case 30:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType)
 			}
-			var stringLen uint64
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -7686,31 +7205,22 @@ func (m *ContainerSpec_DNSConfig) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-			m.Options = append(m.Options, string(dAtA[iNdEx:postIndex]))
-			iNdEx = postIndex
+			m.Privileged = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipSpecs(dAtA[iNdEx:])
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -7725,7 +7235,7 @@ func (m *ContainerSpec_DNSConfig) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ContainerSpec_Ulimit) Unmarshal(dAtA []byte) error {
+func (m *ContainerSpec_PullOptions) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7748,15 +7258,15 @@ func (m *ContainerSpec_Ulimit) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Ulimit: wiretype end group for non-group")
+			return fmt.Errorf("proto: PullOptions: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Ulimit: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: PullOptions: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
+		case 64:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RegistryAuth", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -7784,53 +7294,18 @@ func (m *ContainerSpec_Ulimit) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Name = string(dAtA[iNdEx:postIndex])
+			m.RegistryAuth = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Soft", wireType)
-			}
-			m.Soft = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSpecs
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Soft |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Hard", wireType)
-			}
-			m.Hard = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSpecs
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Hard |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipSpecs(dAtA[iNdEx:])
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -7845,7 +7320,7 @@ func (m *ContainerSpec_Ulimit) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *EndpointSpec) Unmarshal(dAtA []byte) error {
+func (m *ContainerSpec_DNSConfig) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7868,17 +7343,17 @@ func (m *EndpointSpec) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: EndpointSpec: wiretype end group for non-group")
+			return fmt.Errorf("proto: DNSConfig: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EndpointSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: DNSConfig: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Nameservers", wireType)
 			}
-			m.Mode = 0
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -7888,16 +7363,29 @@ func (m *EndpointSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Mode |= EndpointSpec_ResolutionMode(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Nameservers = append(m.Nameservers, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Search", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -7907,25 +7395,55 @@ func (m *EndpointSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthSpecs
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Ports = append(m.Ports, &PortConfig{})
-			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.Search = append(m.Search, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSpecs
+				}
+				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 ErrInvalidLengthSpecs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
 			}
+			m.Options = append(m.Options, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -7933,7 +7451,10 @@ func (m *EndpointSpec) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -7948,7 +7469,7 @@ func (m *EndpointSpec) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *NetworkSpec) Unmarshal(dAtA []byte) error {
+func (m *ContainerSpec_Ulimit) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7971,17 +7492,17 @@ func (m *NetworkSpec) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: NetworkSpec: wiretype end group for non-group")
+			return fmt.Errorf("proto: Ulimit: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: NetworkSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Ulimit: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -7991,66 +7512,29 @@ func (m *NetworkSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthSpecs
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.Annotations.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Name = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DriverConfig", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSpecs
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.DriverConfig == nil {
-				m.DriverConfig = &Driver{}
-			}
-			if err := m.DriverConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Enabled", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Soft", wireType)
 			}
-			var v int
+			m.Soft = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8060,17 +7544,16 @@ func (m *NetworkSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.Soft |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Ipv6Enabled = bool(v != 0)
-		case 4:
+		case 3:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Internal", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Hard", wireType)
 			}
-			var v int
+			m.Hard = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8080,73 +7563,69 @@ func (m *NetworkSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.Hard |= int64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Internal = bool(v != 0)
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IPAM", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSpecs
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipSpecs(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			if msglen < 0 {
+			if skippy < 0 {
 				return ErrInvalidLengthSpecs
 			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *EndpointSpec) 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 ErrIntOverflowSpecs
+			}
+			if iNdEx >= l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.IPAM == nil {
-				m.IPAM = &IPAMOptions{}
-			}
-			if err := m.IPAM.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 6:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Attachable", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSpecs
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
 			}
-			m.Attachable = bool(v != 0)
-		case 7:
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: EndpointSpec: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: EndpointSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
 			}
-			var v int
+			m.Mode = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8156,17 +7635,16 @@ func (m *NetworkSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.Mode |= EndpointSpec_ResolutionMode(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Ingress = bool(v != 0)
-		case 8:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8176,23 +7654,25 @@ func (m *NetworkSpec) 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 ErrInvalidLengthSpecs
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ConfigFrom = &NetworkSpec_Network{string(dAtA[iNdEx:postIndex])}
+			m.Ports = append(m.Ports, &PortConfig{})
+			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -8200,7 +7680,10 @@ func (m *NetworkSpec) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -8215,7 +7698,7 @@ func (m *NetworkSpec) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
+func (m *NetworkSpec) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8238,10 +7721,10 @@ func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ClusterSpec: wiretype end group for non-group")
+			return fmt.Errorf("proto: NetworkSpec: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ClusterSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: NetworkSpec: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -8279,7 +7762,7 @@ func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AcceptancePolicy", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field DriverConfig", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8306,15 +7789,18 @@ func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.AcceptancePolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.DriverConfig == nil {
+				m.DriverConfig = &Driver{}
+			}
+			if err := m.DriverConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Orchestration", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Enabled", wireType)
 			}
-			var msglen int
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8324,30 +7810,17 @@ func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Orchestration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
+			m.Ipv6Enabled = bool(v != 0)
 		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Raft", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Internal", wireType)
 			}
-			var msglen int
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8357,28 +7830,15 @@ func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Raft.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
+			m.Internal = bool(v != 0)
 		case 5:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Dispatcher", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IPAM", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8405,15 +7865,18 @@ func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.Dispatcher.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.IPAM == nil {
+				m.IPAM = &IPAMOptions{}
+			}
+			if err := m.IPAM.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CAConfig", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Attachable", wireType)
 			}
-			var msglen int
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8423,30 +7886,17 @@ func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.CAConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
+			m.Attachable = bool(v != 0)
 		case 7:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TaskDefaults", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
 			}
-			var msglen int
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8456,30 +7906,17 @@ func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.TaskDefaults.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
+			m.Ingress = bool(v != 0)
 		case 8:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EncryptionConfig", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8489,24 +7926,23 @@ func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthSpecs
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.EncryptionConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.ConfigFrom = &NetworkSpec_Network{string(dAtA[iNdEx:postIndex])}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -8514,7 +7950,10 @@ func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -8529,7 +7968,7 @@ func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *SecretSpec) Unmarshal(dAtA []byte) error {
+func (m *ClusterSpec) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8552,10 +7991,10 @@ func (m *SecretSpec) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: SecretSpec: wiretype end group for non-group")
+			return fmt.Errorf("proto: ClusterSpec: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: SecretSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ClusterSpec: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -8593,9 +8032,9 @@ func (m *SecretSpec) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field AcceptancePolicy", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8605,29 +8044,61 @@ func (m *SecretSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthSpecs
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
-			if m.Data == nil {
-				m.Data = []byte{}
+			if err := m.AcceptancePolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Templating", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Orchestration", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSpecs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Orchestration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Raft", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8654,16 +8125,13 @@ func (m *SecretSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Templating == nil {
-				m.Templating = &Driver{}
-			}
-			if err := m.Templating.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Raft.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 4:
+		case 5:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Dispatcher", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8690,66 +8158,13 @@ func (m *SecretSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Driver == nil {
-				m.Driver = &Driver{}
-			}
-			if err := m.Driver.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Dispatcher.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipSpecs(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthSpecs
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *ConfigSpec) 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 ErrIntOverflowSpecs
-			}
-			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: ConfigSpec: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ConfigSpec: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+		case 6:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field CAConfig", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8776,15 +8191,15 @@ func (m *ConfigSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.Annotations.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.CAConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 2:
+		case 7:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TaskDefaults", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8794,29 +8209,28 @@ func (m *ConfigSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthSpecs
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
-			if m.Data == nil {
-				m.Data = []byte{}
+			if err := m.TaskDefaults.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
-		case 3:
+		case 8:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Templating", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EncryptionConfig", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8843,10 +8257,7 @@ func (m *ConfigSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Templating == nil {
-				m.Templating = &Driver{}
-			}
-			if err := m.Templating.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.EncryptionConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -8856,7 +8267,10 @@ func (m *ConfigSpec) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -8871,7 +8285,7 @@ func (m *ConfigSpec) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *VolumeSpec) Unmarshal(dAtA []byte) error {
+func (m *SecretSpec) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8894,10 +8308,10 @@ func (m *VolumeSpec) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: VolumeSpec: wiretype end group for non-group")
+			return fmt.Errorf("proto: SecretSpec: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: VolumeSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: SecretSpec: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -8935,9 +8349,9 @@ func (m *VolumeSpec) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
 			}
-			var stringLen uint64
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -8947,27 +8361,29 @@ func (m *VolumeSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthSpecs
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + byteLen
 			if postIndex < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Group = string(dAtA[iNdEx:postIndex])
+			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
+			if m.Data == nil {
+				m.Data = []byte{}
+			}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Templating", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8994,16 +8410,16 @@ func (m *VolumeSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Driver == nil {
-				m.Driver = &Driver{}
+			if m.Templating == nil {
+				m.Templating = &Driver{}
 			}
-			if err := m.Driver.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Templating.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AccessMode", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -9030,16 +8446,69 @@ func (m *VolumeSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.AccessMode == nil {
-				m.AccessMode = &VolumeAccessMode{}
+			if m.Driver == nil {
+				m.Driver = &Driver{}
 			}
-			if err := m.AccessMode.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Driver.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 5:
+		default:
+			iNdEx = preIndex
+			skippy, err := skipSpecs(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ConfigSpec) 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 ErrIntOverflowSpecs
+			}
+			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: ConfigSpec: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ConfigSpec: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Secrets", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -9066,16 +8535,15 @@ func (m *VolumeSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Secrets = append(m.Secrets, &VolumeSecret{})
-			if err := m.Secrets[len(m.Secrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Annotations.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 6:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AccessibilityRequirements", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowSpecs
@@ -9085,31 +8553,29 @@ func (m *VolumeSpec) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthSpecs
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.AccessibilityRequirements == nil {
-				m.AccessibilityRequirements = &TopologyRequirement{}
-			}
-			if err := m.AccessibilityRequirements.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
+			if m.Data == nil {
+				m.Data = []byte{}
 			}
 			iNdEx = postIndex
-		case 7:
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CapacityRange", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Templating", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -9136,39 +8602,23 @@ func (m *VolumeSpec) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.CapacityRange == nil {
-				m.CapacityRange = &CapacityRange{}
+			if m.Templating == nil {
+				m.Templating = &Driver{}
 			}
-			if err := m.CapacityRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Templating.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 8:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Availability", wireType)
-			}
-			m.Availability = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSpecs
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Availability |= VolumeSpec_VolumeAvailability(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipSpecs(dAtA[iNdEx:])
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthSpecs
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthSpecs
 			}
 			if (iNdEx + skippy) > l {
@@ -9186,7 +8636,6 @@ func (m *VolumeSpec) Unmarshal(dAtA []byte) error {
 func skipSpecs(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
-	depth := 0
 	for iNdEx < l {
 		var wire uint64
 		for shift := uint(0); ; shift += 7 {
@@ -9218,8 +8667,10 @@ func skipSpecs(dAtA []byte) (n int, err error) {
 					break
 				}
 			}
+			return iNdEx, nil
 		case 1:
 			iNdEx += 8
+			return iNdEx, nil
 		case 2:
 			var length int
 			for shift := uint(0); ; shift += 7 {
@@ -9240,30 +8691,55 @@ func skipSpecs(dAtA []byte) (n int, err error) {
 				return 0, ErrInvalidLengthSpecs
 			}
 			iNdEx += length
+			if iNdEx < 0 {
+				return 0, ErrInvalidLengthSpecs
+			}
+			return iNdEx, nil
 		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupSpecs
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowSpecs
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipSpecs(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+				if iNdEx < 0 {
+					return 0, ErrInvalidLengthSpecs
+				}
 			}
-			depth--
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
 		case 5:
 			iNdEx += 4
+			return iNdEx, nil
 		default:
 			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthSpecs
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
 	}
-	return 0, io.ErrUnexpectedEOF
+	panic("unreachable")
 }
 
 var (
-	ErrInvalidLengthSpecs        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowSpecs          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupSpecs = fmt.Errorf("proto: unexpected end of group")
+	ErrInvalidLengthSpecs = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowSpecs   = fmt.Errorf("proto: integer overflow")
 )
diff --git a/api/specs.proto b/api/specs.proto
index a097b2be3c..545085eccb 100644
--- a/api/specs.proto
+++ b/api/specs.proto
@@ -370,6 +370,8 @@ message ContainerSpec {
 	// Ulimits defines the list of ulimits to set in the container. This option
 	// is equivalent to passing --ulimit to docker run.
 	repeated Ulimit ulimits = 29;
+
+	bool privileged = 30;
 }
 
 // EndpointSpec defines the properties that can be configured to
@@ -506,71 +508,3 @@ message ConfigSpec {
 	// - golang: Go templating
 	Driver templating = 3;
 }
-
-message VolumeSpec {
-	// Annotations includes the name and labels of a volume. The name used in the
-	// spec's Annotations will be passed to the Plugin as the "Name" in the
-	// CreateVolume request.
-	Annotations annotations = 1 [(gogoproto.nullable) = false];
-
-	// Group defines the volume group this particular volume belongs to. When
-	// requesting volumes for a workload, the group name can be used instead of
-	// the volume's name, which tells swarmkit to pick one from the many volumes
-	// belonging to that group.
-	string group = 2;
-
-	// Driver represents the CSI Plugin object and its configuration parameters.
-	// The "options" field of the Driver object is passed in the CSI
-	// CreateVolumeRequest as the "parameters" field. The Driver must be
-	// specified; there is no default CSI Plugin.
-	Driver driver = 3;
-
-	// AccessMode is similar to, and used to determine, the volume access mode as
-	// defined in the CSI spec, as well as the volume type (block vs mount). In
-	// this way, it is more similar to the VolumeCapability message in the CSI
-	// spec.
-	VolumeAccessMode access_mode = 4;
-
-	// Secrets represents a set of key/value pairs to pass to the CSI plugin. The
-	// keys of the secrets can be anything, but the values refer to swarmkit
-	// Secret objects. See the "Secrets Requirements" section of the CSI Plugin
-	// Spec for more information.
-	repeated VolumeSecret secrets = 5;
-
-	// AccessibilityRequirements specifies where a volume must be accessible
-	// from.
-	//
-	// This field must be empty if the plugin does not support
-	// VOLUME_ACCESSIBILITY_CONSTRAINTS capabilities. If it is present but the
-	// plugin does not support it, volume will not be created.
-	//
-	// If AccessibilityRequirements is empty, but the plugin does support
-	// VOLUME_ACCESSIBILITY_CONSTRAINTS, then Swarmkit will assume the entire
-	// cluster is a valid target for the volume.
-	TopologyRequirement AccessibilityRequirements = 6;
-
-	// CapacityRange is the capacity this volume should be created with. If nil,
-	// the plugin will decide the capacity.
-	CapacityRange capacity_range = 7;
-
-	enum VolumeAvailability {
-		option (gogoproto.goproto_enum_prefix) = false;
-
-		// Active allows a volume to be used and scheduled to. This is the
-		// default state.
-		ACTIVE = 0 [(gogoproto.enumvalue_customname) = "VolumeAvailabilityActive"];
-
-		// Pause prevents volumes from having new workloads scheduled to use
-		// them, even if they're already published on a Node.
-		PAUSE = 1 [(gogoproto.enumvalue_customname) = "VolumeAvailabilityPause"];
-
-		// Drain causes existing workloads using this volume to be rescheduled,
-		// causing the volume to be unpublished and removed from nodes.
-		DRAIN = 2 [(gogoproto.enumvalue_customname) = "VolumeAvailabilityDrain"];
-	}
-
-	// Availability is the Volume's desired availability. Analogous to Node
-	// Availability, this allows the user to take volumes offline in order to
-	// update or delete them.
-	VolumeAvailability availability = 8;
-}