// Code generated by protoc-gen-go. DO NOT EDIT.
// source: api.proto

package proto

import (
	context "context"
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

// The response message containing the reboot status.
type RebootReply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RebootReply) Reset()         { *m = RebootReply{} }
func (m *RebootReply) String() string { return proto.CompactTextString(m) }
func (*RebootReply) ProtoMessage()    {}
func (*RebootReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{0}
}

func (m *RebootReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RebootReply.Unmarshal(m, b)
}

func (m *RebootReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RebootReply.Marshal(b, m, deterministic)
}

func (m *RebootReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RebootReply.Merge(m, src)
}

func (m *RebootReply) XXX_Size() int {
	return xxx_messageInfo_RebootReply.Size(m)
}

func (m *RebootReply) XXX_DiscardUnknown() {
	xxx_messageInfo_RebootReply.DiscardUnknown(m)
}

var xxx_messageInfo_RebootReply proto.InternalMessageInfo

// The response message containing the restart status.
type ResetReply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ResetReply) Reset()         { *m = ResetReply{} }
func (m *ResetReply) String() string { return proto.CompactTextString(m) }
func (*ResetReply) ProtoMessage()    {}
func (*ResetReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{1}
}

func (m *ResetReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ResetReply.Unmarshal(m, b)
}

func (m *ResetReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ResetReply.Marshal(b, m, deterministic)
}

func (m *ResetReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResetReply.Merge(m, src)
}

func (m *ResetReply) XXX_Size() int {
	return xxx_messageInfo_ResetReply.Size(m)
}

func (m *ResetReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ResetReply.DiscardUnknown(m)
}

var xxx_messageInfo_ResetReply proto.InternalMessageInfo

// The response message containing the shutdown status.
type ShutdownReply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ShutdownReply) Reset()         { *m = ShutdownReply{} }
func (m *ShutdownReply) String() string { return proto.CompactTextString(m) }
func (*ShutdownReply) ProtoMessage()    {}
func (*ShutdownReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{2}
}

func (m *ShutdownReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShutdownReply.Unmarshal(m, b)
}

func (m *ShutdownReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShutdownReply.Marshal(b, m, deterministic)
}

func (m *ShutdownReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShutdownReply.Merge(m, src)
}

func (m *ShutdownReply) XXX_Size() int {
	return xxx_messageInfo_ShutdownReply.Size(m)
}

func (m *ShutdownReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ShutdownReply.DiscardUnknown(m)
}

var xxx_messageInfo_ShutdownReply proto.InternalMessageInfo

type UpgradeRequest struct {
	Image                string   `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpgradeRequest) Reset()         { *m = UpgradeRequest{} }
func (m *UpgradeRequest) String() string { return proto.CompactTextString(m) }
func (*UpgradeRequest) ProtoMessage()    {}
func (*UpgradeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{3}
}

func (m *UpgradeRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpgradeRequest.Unmarshal(m, b)
}

func (m *UpgradeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpgradeRequest.Marshal(b, m, deterministic)
}

func (m *UpgradeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpgradeRequest.Merge(m, src)
}

func (m *UpgradeRequest) XXX_Size() int {
	return xxx_messageInfo_UpgradeRequest.Size(m)
}

func (m *UpgradeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpgradeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpgradeRequest proto.InternalMessageInfo

func (m *UpgradeRequest) GetImage() string {
	if m != nil {
		return m.Image
	}
	return ""
}

type UpgradeReply struct {
	Ack                  string   `protobuf:"bytes,1,opt,name=ack,proto3" json:"ack,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpgradeReply) Reset()         { *m = UpgradeReply{} }
func (m *UpgradeReply) String() string { return proto.CompactTextString(m) }
func (*UpgradeReply) ProtoMessage()    {}
func (*UpgradeReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{4}
}

func (m *UpgradeReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpgradeReply.Unmarshal(m, b)
}

func (m *UpgradeReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpgradeReply.Marshal(b, m, deterministic)
}

func (m *UpgradeReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpgradeReply.Merge(m, src)
}

func (m *UpgradeReply) XXX_Size() int {
	return xxx_messageInfo_UpgradeReply.Size(m)
}

func (m *UpgradeReply) XXX_DiscardUnknown() {
	xxx_messageInfo_UpgradeReply.DiscardUnknown(m)
}

var xxx_messageInfo_UpgradeReply proto.InternalMessageInfo

func (m *UpgradeReply) GetAck() string {
	if m != nil {
		return m.Ack
	}
	return ""
}

type ServiceListReply struct {
	Services             []*ServiceInfo `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *ServiceListReply) Reset()         { *m = ServiceListReply{} }
func (m *ServiceListReply) String() string { return proto.CompactTextString(m) }
func (*ServiceListReply) ProtoMessage()    {}
func (*ServiceListReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{5}
}

func (m *ServiceListReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceListReply.Unmarshal(m, b)
}

func (m *ServiceListReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceListReply.Marshal(b, m, deterministic)
}

func (m *ServiceListReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceListReply.Merge(m, src)
}

func (m *ServiceListReply) XXX_Size() int {
	return xxx_messageInfo_ServiceListReply.Size(m)
}

func (m *ServiceListReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceListReply.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceListReply proto.InternalMessageInfo

func (m *ServiceListReply) GetServices() []*ServiceInfo {
	if m != nil {
		return m.Services
	}
	return nil
}

type ServiceInfo struct {
	Id                   string         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	State                string         `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
	Events               *ServiceEvents `protobuf:"bytes,3,opt,name=events,proto3" json:"events,omitempty"`
	Health               *ServiceHealth `protobuf:"bytes,4,opt,name=health,proto3" json:"health,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *ServiceInfo) Reset()         { *m = ServiceInfo{} }
func (m *ServiceInfo) String() string { return proto.CompactTextString(m) }
func (*ServiceInfo) ProtoMessage()    {}
func (*ServiceInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{6}
}

func (m *ServiceInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceInfo.Unmarshal(m, b)
}

func (m *ServiceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceInfo.Marshal(b, m, deterministic)
}

func (m *ServiceInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceInfo.Merge(m, src)
}

func (m *ServiceInfo) XXX_Size() int {
	return xxx_messageInfo_ServiceInfo.Size(m)
}

func (m *ServiceInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceInfo proto.InternalMessageInfo

func (m *ServiceInfo) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *ServiceInfo) GetState() string {
	if m != nil {
		return m.State
	}
	return ""
}

func (m *ServiceInfo) GetEvents() *ServiceEvents {
	if m != nil {
		return m.Events
	}
	return nil
}

func (m *ServiceInfo) GetHealth() *ServiceHealth {
	if m != nil {
		return m.Health
	}
	return nil
}

type ServiceEvents struct {
	Events               []*ServiceEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *ServiceEvents) Reset()         { *m = ServiceEvents{} }
func (m *ServiceEvents) String() string { return proto.CompactTextString(m) }
func (*ServiceEvents) ProtoMessage()    {}
func (*ServiceEvents) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{7}
}

func (m *ServiceEvents) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceEvents.Unmarshal(m, b)
}

func (m *ServiceEvents) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceEvents.Marshal(b, m, deterministic)
}

func (m *ServiceEvents) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceEvents.Merge(m, src)
}

func (m *ServiceEvents) XXX_Size() int {
	return xxx_messageInfo_ServiceEvents.Size(m)
}

func (m *ServiceEvents) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceEvents.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceEvents proto.InternalMessageInfo

func (m *ServiceEvents) GetEvents() []*ServiceEvent {
	if m != nil {
		return m.Events
	}
	return nil
}

type ServiceEvent struct {
	Msg                  string               `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
	State                string               `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
	Ts                   *timestamp.Timestamp `protobuf:"bytes,3,opt,name=ts,proto3" json:"ts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ServiceEvent) Reset()         { *m = ServiceEvent{} }
func (m *ServiceEvent) String() string { return proto.CompactTextString(m) }
func (*ServiceEvent) ProtoMessage()    {}
func (*ServiceEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{8}
}

func (m *ServiceEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceEvent.Unmarshal(m, b)
}

func (m *ServiceEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceEvent.Marshal(b, m, deterministic)
}

func (m *ServiceEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceEvent.Merge(m, src)
}

func (m *ServiceEvent) XXX_Size() int {
	return xxx_messageInfo_ServiceEvent.Size(m)
}

func (m *ServiceEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceEvent.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceEvent proto.InternalMessageInfo

func (m *ServiceEvent) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func (m *ServiceEvent) GetState() string {
	if m != nil {
		return m.State
	}
	return ""
}

func (m *ServiceEvent) GetTs() *timestamp.Timestamp {
	if m != nil {
		return m.Ts
	}
	return nil
}

type ServiceHealth struct {
	Unknown              bool                 `protobuf:"varint,1,opt,name=unknown,proto3" json:"unknown,omitempty"`
	Healthy              bool                 `protobuf:"varint,2,opt,name=healthy,proto3" json:"healthy,omitempty"`
	LastMessage          string               `protobuf:"bytes,3,opt,name=last_message,json=lastMessage,proto3" json:"last_message,omitempty"`
	LastChange           *timestamp.Timestamp `protobuf:"bytes,4,opt,name=last_change,json=lastChange,proto3" json:"last_change,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ServiceHealth) Reset()         { *m = ServiceHealth{} }
func (m *ServiceHealth) String() string { return proto.CompactTextString(m) }
func (*ServiceHealth) ProtoMessage()    {}
func (*ServiceHealth) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{9}
}

func (m *ServiceHealth) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceHealth.Unmarshal(m, b)
}

func (m *ServiceHealth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceHealth.Marshal(b, m, deterministic)
}

func (m *ServiceHealth) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceHealth.Merge(m, src)
}

func (m *ServiceHealth) XXX_Size() int {
	return xxx_messageInfo_ServiceHealth.Size(m)
}

func (m *ServiceHealth) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceHealth.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceHealth proto.InternalMessageInfo

func (m *ServiceHealth) GetUnknown() bool {
	if m != nil {
		return m.Unknown
	}
	return false
}

func (m *ServiceHealth) GetHealthy() bool {
	if m != nil {
		return m.Healthy
	}
	return false
}

func (m *ServiceHealth) GetLastMessage() string {
	if m != nil {
		return m.LastMessage
	}
	return ""
}

func (m *ServiceHealth) GetLastChange() *timestamp.Timestamp {
	if m != nil {
		return m.LastChange
	}
	return nil
}

type ServiceStartRequest struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServiceStartRequest) Reset()         { *m = ServiceStartRequest{} }
func (m *ServiceStartRequest) String() string { return proto.CompactTextString(m) }
func (*ServiceStartRequest) ProtoMessage()    {}
func (*ServiceStartRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{10}
}

func (m *ServiceStartRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceStartRequest.Unmarshal(m, b)
}

func (m *ServiceStartRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceStartRequest.Marshal(b, m, deterministic)
}

func (m *ServiceStartRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceStartRequest.Merge(m, src)
}

func (m *ServiceStartRequest) XXX_Size() int {
	return xxx_messageInfo_ServiceStartRequest.Size(m)
}

func (m *ServiceStartRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceStartRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceStartRequest proto.InternalMessageInfo

func (m *ServiceStartRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type ServiceStartReply struct {
	Resp                 string   `protobuf:"bytes,1,opt,name=resp,proto3" json:"resp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServiceStartReply) Reset()         { *m = ServiceStartReply{} }
func (m *ServiceStartReply) String() string { return proto.CompactTextString(m) }
func (*ServiceStartReply) ProtoMessage()    {}
func (*ServiceStartReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{11}
}

func (m *ServiceStartReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceStartReply.Unmarshal(m, b)
}

func (m *ServiceStartReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceStartReply.Marshal(b, m, deterministic)
}

func (m *ServiceStartReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceStartReply.Merge(m, src)
}

func (m *ServiceStartReply) XXX_Size() int {
	return xxx_messageInfo_ServiceStartReply.Size(m)
}

func (m *ServiceStartReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceStartReply.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceStartReply proto.InternalMessageInfo

func (m *ServiceStartReply) GetResp() string {
	if m != nil {
		return m.Resp
	}
	return ""
}

type ServiceStopRequest struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServiceStopRequest) Reset()         { *m = ServiceStopRequest{} }
func (m *ServiceStopRequest) String() string { return proto.CompactTextString(m) }
func (*ServiceStopRequest) ProtoMessage()    {}
func (*ServiceStopRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{12}
}

func (m *ServiceStopRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceStopRequest.Unmarshal(m, b)
}

func (m *ServiceStopRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceStopRequest.Marshal(b, m, deterministic)
}

func (m *ServiceStopRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceStopRequest.Merge(m, src)
}

func (m *ServiceStopRequest) XXX_Size() int {
	return xxx_messageInfo_ServiceStopRequest.Size(m)
}

func (m *ServiceStopRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceStopRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceStopRequest proto.InternalMessageInfo

func (m *ServiceStopRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type ServiceStopReply struct {
	Resp                 string   `protobuf:"bytes,1,opt,name=resp,proto3" json:"resp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServiceStopReply) Reset()         { *m = ServiceStopReply{} }
func (m *ServiceStopReply) String() string { return proto.CompactTextString(m) }
func (*ServiceStopReply) ProtoMessage()    {}
func (*ServiceStopReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{13}
}

func (m *ServiceStopReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceStopReply.Unmarshal(m, b)
}

func (m *ServiceStopReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceStopReply.Marshal(b, m, deterministic)
}

func (m *ServiceStopReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceStopReply.Merge(m, src)
}

func (m *ServiceStopReply) XXX_Size() int {
	return xxx_messageInfo_ServiceStopReply.Size(m)
}

func (m *ServiceStopReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceStopReply.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceStopReply proto.InternalMessageInfo

func (m *ServiceStopReply) GetResp() string {
	if m != nil {
		return m.Resp
	}
	return ""
}

type ServiceRestartRequest struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServiceRestartRequest) Reset()         { *m = ServiceRestartRequest{} }
func (m *ServiceRestartRequest) String() string { return proto.CompactTextString(m) }
func (*ServiceRestartRequest) ProtoMessage()    {}
func (*ServiceRestartRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{14}
}

func (m *ServiceRestartRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceRestartRequest.Unmarshal(m, b)
}

func (m *ServiceRestartRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceRestartRequest.Marshal(b, m, deterministic)
}

func (m *ServiceRestartRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceRestartRequest.Merge(m, src)
}

func (m *ServiceRestartRequest) XXX_Size() int {
	return xxx_messageInfo_ServiceRestartRequest.Size(m)
}

func (m *ServiceRestartRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceRestartRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceRestartRequest proto.InternalMessageInfo

func (m *ServiceRestartRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type ServiceRestartReply struct {
	Resp                 string   `protobuf:"bytes,1,opt,name=resp,proto3" json:"resp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServiceRestartReply) Reset()         { *m = ServiceRestartReply{} }
func (m *ServiceRestartReply) String() string { return proto.CompactTextString(m) }
func (*ServiceRestartReply) ProtoMessage()    {}
func (*ServiceRestartReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{15}
}

func (m *ServiceRestartReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceRestartReply.Unmarshal(m, b)
}

func (m *ServiceRestartReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceRestartReply.Marshal(b, m, deterministic)
}

func (m *ServiceRestartReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceRestartReply.Merge(m, src)
}

func (m *ServiceRestartReply) XXX_Size() int {
	return xxx_messageInfo_ServiceRestartReply.Size(m)
}

func (m *ServiceRestartReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceRestartReply.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceRestartReply proto.InternalMessageInfo

func (m *ServiceRestartReply) GetResp() string {
	if m != nil {
		return m.Resp
	}
	return ""
}

// Deprecated: Do not use.
type StartRequest struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StartRequest) Reset()         { *m = StartRequest{} }
func (m *StartRequest) String() string { return proto.CompactTextString(m) }
func (*StartRequest) ProtoMessage()    {}
func (*StartRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{16}
}

func (m *StartRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StartRequest.Unmarshal(m, b)
}

func (m *StartRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StartRequest.Marshal(b, m, deterministic)
}

func (m *StartRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StartRequest.Merge(m, src)
}

func (m *StartRequest) XXX_Size() int {
	return xxx_messageInfo_StartRequest.Size(m)
}

func (m *StartRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StartRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StartRequest proto.InternalMessageInfo

func (m *StartRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

// Deprecated: Do not use.
type StartReply struct {
	Resp                 string   `protobuf:"bytes,1,opt,name=resp,proto3" json:"resp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StartReply) Reset()         { *m = StartReply{} }
func (m *StartReply) String() string { return proto.CompactTextString(m) }
func (*StartReply) ProtoMessage()    {}
func (*StartReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{17}
}

func (m *StartReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StartReply.Unmarshal(m, b)
}

func (m *StartReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StartReply.Marshal(b, m, deterministic)
}

func (m *StartReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StartReply.Merge(m, src)
}

func (m *StartReply) XXX_Size() int {
	return xxx_messageInfo_StartReply.Size(m)
}

func (m *StartReply) XXX_DiscardUnknown() {
	xxx_messageInfo_StartReply.DiscardUnknown(m)
}

var xxx_messageInfo_StartReply proto.InternalMessageInfo

func (m *StartReply) GetResp() string {
	if m != nil {
		return m.Resp
	}
	return ""
}

// Deprecated: Do not use.
type StopRequest struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StopRequest) Reset()         { *m = StopRequest{} }
func (m *StopRequest) String() string { return proto.CompactTextString(m) }
func (*StopRequest) ProtoMessage()    {}
func (*StopRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{18}
}

func (m *StopRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StopRequest.Unmarshal(m, b)
}

func (m *StopRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StopRequest.Marshal(b, m, deterministic)
}

func (m *StopRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StopRequest.Merge(m, src)
}

func (m *StopRequest) XXX_Size() int {
	return xxx_messageInfo_StopRequest.Size(m)
}

func (m *StopRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StopRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StopRequest proto.InternalMessageInfo

func (m *StopRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

// Deprecated: Do not use.
type StopReply struct {
	Resp                 string   `protobuf:"bytes,1,opt,name=resp,proto3" json:"resp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StopReply) Reset()         { *m = StopReply{} }
func (m *StopReply) String() string { return proto.CompactTextString(m) }
func (*StopReply) ProtoMessage()    {}
func (*StopReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{19}
}

func (m *StopReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StopReply.Unmarshal(m, b)
}

func (m *StopReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StopReply.Marshal(b, m, deterministic)
}

func (m *StopReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StopReply.Merge(m, src)
}

func (m *StopReply) XXX_Size() int {
	return xxx_messageInfo_StopReply.Size(m)
}

func (m *StopReply) XXX_DiscardUnknown() {
	xxx_messageInfo_StopReply.DiscardUnknown(m)
}

var xxx_messageInfo_StopReply proto.InternalMessageInfo

func (m *StopReply) GetResp() string {
	if m != nil {
		return m.Resp
	}
	return ""
}

// StreamingData is used to stream back responses
type StreamingData struct {
	Bytes                []byte   `protobuf:"bytes,1,opt,name=bytes,proto3" json:"bytes,omitempty"`
	Errors               string   `protobuf:"bytes,2,opt,name=errors,proto3" json:"errors,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamingData) Reset()         { *m = StreamingData{} }
func (m *StreamingData) String() string { return proto.CompactTextString(m) }
func (*StreamingData) ProtoMessage()    {}
func (*StreamingData) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{20}
}

func (m *StreamingData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamingData.Unmarshal(m, b)
}

func (m *StreamingData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamingData.Marshal(b, m, deterministic)
}

func (m *StreamingData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamingData.Merge(m, src)
}

func (m *StreamingData) XXX_Size() int {
	return xxx_messageInfo_StreamingData.Size(m)
}

func (m *StreamingData) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamingData.DiscardUnknown(m)
}

var xxx_messageInfo_StreamingData proto.InternalMessageInfo

func (m *StreamingData) GetBytes() []byte {
	if m != nil {
		return m.Bytes
	}
	return nil
}

func (m *StreamingData) GetErrors() string {
	if m != nil {
		return m.Errors
	}
	return ""
}

// CopyOutRequest describes a request to copy data out of Talos node
//
// CopyOut produces .tar.gz archive which is streamed back to the caller
type CopyOutRequest struct {
	// Root path to start copying data out, it might be either a file or directory
	RootPath             string   `protobuf:"bytes,1,opt,name=root_path,json=rootPath,proto3" json:"root_path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CopyOutRequest) Reset()         { *m = CopyOutRequest{} }
func (m *CopyOutRequest) String() string { return proto.CompactTextString(m) }
func (*CopyOutRequest) ProtoMessage()    {}
func (*CopyOutRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{21}
}

func (m *CopyOutRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CopyOutRequest.Unmarshal(m, b)
}

func (m *CopyOutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CopyOutRequest.Marshal(b, m, deterministic)
}

func (m *CopyOutRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CopyOutRequest.Merge(m, src)
}

func (m *CopyOutRequest) XXX_Size() int {
	return xxx_messageInfo_CopyOutRequest.Size(m)
}

func (m *CopyOutRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CopyOutRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CopyOutRequest proto.InternalMessageInfo

func (m *CopyOutRequest) GetRootPath() string {
	if m != nil {
		return m.RootPath
	}
	return ""
}

// LSRequest describes a request to list the contents of a directory
type LSRequest struct {
	// Root indicates the root directory for the list.  If not indicated, '/' is
	// presumed.
	Root string `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"`
	// Recurse indicates that subdirectories should be recursed.
	Recurse bool `protobuf:"varint,2,opt,name=recurse,proto3" json:"recurse,omitempty"`
	// RecursionDepth indicates how many levels of subdirectories should be
	// recursed.  The default (0) indicates that no limit should be enforced.
	RecursionDepth       int32    `protobuf:"varint,3,opt,name=recursion_depth,json=recursionDepth,proto3" json:"recursion_depth,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LSRequest) Reset()         { *m = LSRequest{} }
func (m *LSRequest) String() string { return proto.CompactTextString(m) }
func (*LSRequest) ProtoMessage()    {}
func (*LSRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{22}
}

func (m *LSRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LSRequest.Unmarshal(m, b)
}

func (m *LSRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LSRequest.Marshal(b, m, deterministic)
}

func (m *LSRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LSRequest.Merge(m, src)
}

func (m *LSRequest) XXX_Size() int {
	return xxx_messageInfo_LSRequest.Size(m)
}

func (m *LSRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LSRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LSRequest proto.InternalMessageInfo

func (m *LSRequest) GetRoot() string {
	if m != nil {
		return m.Root
	}
	return ""
}

func (m *LSRequest) GetRecurse() bool {
	if m != nil {
		return m.Recurse
	}
	return false
}

func (m *LSRequest) GetRecursionDepth() int32 {
	if m != nil {
		return m.RecursionDepth
	}
	return 0
}

// FileInfo describes a file or directory's information
type FileInfo struct {
	// Name is the name (including prefixed path) of the file or directory
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Size indicates the number of bytes contained within the file
	Size int64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	// Mode is the bitmap of UNIX mode/permission flags of the file
	Mode uint32 `protobuf:"varint,3,opt,name=mode,proto3" json:"mode,omitempty"`
	// Modified indicates the UNIX timestamp at which the file was last modified
	Modified int64 `protobuf:"varint,4,opt,name=modified,proto3" json:"modified,omitempty"`
	// IsDir indicates that the file is a directory
	IsDir bool `protobuf:"varint,5,opt,name=is_dir,json=isDir,proto3" json:"is_dir,omitempty"`
	// Error describes any error encountered while trying to read the file
	// information.
	Error string `protobuf:"bytes,6,opt,name=error,proto3" json:"error,omitempty"`
	// Link is filled with symlink target
	Link string `protobuf:"bytes,7,opt,name=link,proto3" json:"link,omitempty"`
	// RelativeName is the name of the file or directory relative to the RootPath
	RelativeName         string   `protobuf:"bytes,8,opt,name=relative_name,json=relativeName,proto3" json:"relative_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FileInfo) Reset()         { *m = FileInfo{} }
func (m *FileInfo) String() string { return proto.CompactTextString(m) }
func (*FileInfo) ProtoMessage()    {}
func (*FileInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{23}
}

func (m *FileInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FileInfo.Unmarshal(m, b)
}

func (m *FileInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FileInfo.Marshal(b, m, deterministic)
}

func (m *FileInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileInfo.Merge(m, src)
}

func (m *FileInfo) XXX_Size() int {
	return xxx_messageInfo_FileInfo.Size(m)
}

func (m *FileInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_FileInfo.DiscardUnknown(m)
}

var xxx_messageInfo_FileInfo proto.InternalMessageInfo

func (m *FileInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *FileInfo) GetSize() int64 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *FileInfo) GetMode() uint32 {
	if m != nil {
		return m.Mode
	}
	return 0
}

func (m *FileInfo) GetModified() int64 {
	if m != nil {
		return m.Modified
	}
	return 0
}

func (m *FileInfo) GetIsDir() bool {
	if m != nil {
		return m.IsDir
	}
	return false
}

func (m *FileInfo) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

func (m *FileInfo) GetLink() string {
	if m != nil {
		return m.Link
	}
	return ""
}

func (m *FileInfo) GetRelativeName() string {
	if m != nil {
		return m.RelativeName
	}
	return ""
}

// The response message containing the requested df stats.
type DFReply struct {
	Stats                []*DFStat `protobuf:"bytes,1,rep,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *DFReply) Reset()         { *m = DFReply{} }
func (m *DFReply) String() string { return proto.CompactTextString(m) }
func (*DFReply) ProtoMessage()    {}
func (*DFReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{24}
}

func (m *DFReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DFReply.Unmarshal(m, b)
}

func (m *DFReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DFReply.Marshal(b, m, deterministic)
}

func (m *DFReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DFReply.Merge(m, src)
}

func (m *DFReply) XXX_Size() int {
	return xxx_messageInfo_DFReply.Size(m)
}

func (m *DFReply) XXX_DiscardUnknown() {
	xxx_messageInfo_DFReply.DiscardUnknown(m)
}

var xxx_messageInfo_DFReply proto.InternalMessageInfo

func (m *DFReply) GetStats() []*DFStat {
	if m != nil {
		return m.Stats
	}
	return nil
}

// The response message containing the requested processes.
type DFStat struct {
	Filesystem           string   `protobuf:"bytes,1,opt,name=filesystem,proto3" json:"filesystem,omitempty"`
	Size                 uint64   `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	Available            uint64   `protobuf:"varint,3,opt,name=available,proto3" json:"available,omitempty"`
	MountedOn            string   `protobuf:"bytes,4,opt,name=mounted_on,json=mountedOn,proto3" json:"mounted_on,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DFStat) Reset()         { *m = DFStat{} }
func (m *DFStat) String() string { return proto.CompactTextString(m) }
func (*DFStat) ProtoMessage()    {}
func (*DFStat) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{25}
}

func (m *DFStat) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DFStat.Unmarshal(m, b)
}

func (m *DFStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DFStat.Marshal(b, m, deterministic)
}

func (m *DFStat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DFStat.Merge(m, src)
}

func (m *DFStat) XXX_Size() int {
	return xxx_messageInfo_DFStat.Size(m)
}

func (m *DFStat) XXX_DiscardUnknown() {
	xxx_messageInfo_DFStat.DiscardUnknown(m)
}

var xxx_messageInfo_DFStat proto.InternalMessageInfo

func (m *DFStat) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

func (m *DFStat) GetSize() uint64 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *DFStat) GetAvailable() uint64 {
	if m != nil {
		return m.Available
	}
	return 0
}

func (m *DFStat) GetMountedOn() string {
	if m != nil {
		return m.MountedOn
	}
	return ""
}

type VersionReply struct {
	Tag                  string   `protobuf:"bytes,1,opt,name=tag,proto3" json:"tag,omitempty"`
	Sha                  string   `protobuf:"bytes,2,opt,name=sha,proto3" json:"sha,omitempty"`
	Built                string   `protobuf:"bytes,3,opt,name=built,proto3" json:"built,omitempty"`
	GoVersion            string   `protobuf:"bytes,4,opt,name=go_version,json=goVersion,proto3" json:"go_version,omitempty"`
	Os                   string   `protobuf:"bytes,5,opt,name=os,proto3" json:"os,omitempty"`
	Arch                 string   `protobuf:"bytes,6,opt,name=arch,proto3" json:"arch,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VersionReply) Reset()         { *m = VersionReply{} }
func (m *VersionReply) String() string { return proto.CompactTextString(m) }
func (*VersionReply) ProtoMessage()    {}
func (*VersionReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_00212fb1f9d3bf1c, []int{26}
}

func (m *VersionReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VersionReply.Unmarshal(m, b)
}

func (m *VersionReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VersionReply.Marshal(b, m, deterministic)
}

func (m *VersionReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VersionReply.Merge(m, src)
}

func (m *VersionReply) XXX_Size() int {
	return xxx_messageInfo_VersionReply.Size(m)
}

func (m *VersionReply) XXX_DiscardUnknown() {
	xxx_messageInfo_VersionReply.DiscardUnknown(m)
}

var xxx_messageInfo_VersionReply proto.InternalMessageInfo

func (m *VersionReply) GetTag() string {
	if m != nil {
		return m.Tag
	}
	return ""
}

func (m *VersionReply) GetSha() string {
	if m != nil {
		return m.Sha
	}
	return ""
}

func (m *VersionReply) GetBuilt() string {
	if m != nil {
		return m.Built
	}
	return ""
}

func (m *VersionReply) GetGoVersion() string {
	if m != nil {
		return m.GoVersion
	}
	return ""
}

func (m *VersionReply) GetOs() string {
	if m != nil {
		return m.Os
	}
	return ""
}

func (m *VersionReply) GetArch() string {
	if m != nil {
		return m.Arch
	}
	return ""
}

func init() {
	proto.RegisterType((*RebootReply)(nil), "proto.RebootReply")
	proto.RegisterType((*ResetReply)(nil), "proto.ResetReply")
	proto.RegisterType((*ShutdownReply)(nil), "proto.ShutdownReply")
	proto.RegisterType((*UpgradeRequest)(nil), "proto.UpgradeRequest")
	proto.RegisterType((*UpgradeReply)(nil), "proto.UpgradeReply")
	proto.RegisterType((*ServiceListReply)(nil), "proto.ServiceListReply")
	proto.RegisterType((*ServiceInfo)(nil), "proto.ServiceInfo")
	proto.RegisterType((*ServiceEvents)(nil), "proto.ServiceEvents")
	proto.RegisterType((*ServiceEvent)(nil), "proto.ServiceEvent")
	proto.RegisterType((*ServiceHealth)(nil), "proto.ServiceHealth")
	proto.RegisterType((*ServiceStartRequest)(nil), "proto.ServiceStartRequest")
	proto.RegisterType((*ServiceStartReply)(nil), "proto.ServiceStartReply")
	proto.RegisterType((*ServiceStopRequest)(nil), "proto.ServiceStopRequest")
	proto.RegisterType((*ServiceStopReply)(nil), "proto.ServiceStopReply")
	proto.RegisterType((*ServiceRestartRequest)(nil), "proto.ServiceRestartRequest")
	proto.RegisterType((*ServiceRestartReply)(nil), "proto.ServiceRestartReply")
	proto.RegisterType((*StartRequest)(nil), "proto.StartRequest")
	proto.RegisterType((*StartReply)(nil), "proto.StartReply")
	proto.RegisterType((*StopRequest)(nil), "proto.StopRequest")
	proto.RegisterType((*StopReply)(nil), "proto.StopReply")
	proto.RegisterType((*StreamingData)(nil), "proto.StreamingData")
	proto.RegisterType((*CopyOutRequest)(nil), "proto.CopyOutRequest")
	proto.RegisterType((*LSRequest)(nil), "proto.LSRequest")
	proto.RegisterType((*FileInfo)(nil), "proto.FileInfo")
	proto.RegisterType((*DFReply)(nil), "proto.DFReply")
	proto.RegisterType((*DFStat)(nil), "proto.DFStat")
	proto.RegisterType((*VersionReply)(nil), "proto.VersionReply")
}

func init() { proto.RegisterFile("api.proto", fileDescriptor_00212fb1f9d3bf1c) }

var fileDescriptor_00212fb1f9d3bf1c = []byte{
	// 1103 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x56, 0x5b, 0x73, 0xdc, 0x34,
	0x14, 0x1e, 0xef, 0x7d, 0xcf, 0x5e, 0x92, 0x28, 0x4d, 0x31, 0x6e, 0x29, 0xa9, 0x53, 0x9a, 0x14,
	0xca, 0xb6, 0x84, 0xc2, 0x74, 0xb8, 0xcd, 0x34, 0xdd, 0x66, 0x28, 0x13, 0x68, 0xc6, 0x0b, 0x3c,
	0xf0, 0xb2, 0xa3, 0xdd, 0x55, 0xbc, 0x9a, 0xd8, 0x96, 0xb1, 0xb4, 0xe9, 0x2c, 0xbf, 0x80, 0x19,
	0x1e, 0xf8, 0x11, 0xbc, 0xf1, 0x4b, 0xf8, 0x59, 0x8c, 0x2e, 0x56, 0xec, 0x34, 0xce, 0x93, 0x75,
	0x3e, 0x7d, 0x3a, 0x37, 0x1d, 0x9f, 0x23, 0xe8, 0xe2, 0x94, 0x8e, 0xd2, 0x8c, 0x09, 0x86, 0x9a,
	0xea, 0xe3, 0xdd, 0x09, 0x19, 0x0b, 0x23, 0xf2, 0x44, 0x49, 0xb3, 0xd5, 0xd9, 0x13, 0x12, 0xa7,
	0x62, 0xad, 0x39, 0xde, 0x87, 0x57, 0x37, 0x05, 0x8d, 0x09, 0x17, 0x38, 0x4e, 0x35, 0xc1, 0x1f,
	0x40, 0x2f, 0x20, 0x33, 0xc6, 0x44, 0x40, 0xd2, 0x68, 0xed, 0xf7, 0x01, 0x02, 0xc2, 0x89, 0x91,
	0x36, 0x60, 0x30, 0x59, 0xae, 0xc4, 0x82, 0xbd, 0x4d, 0x34, 0xf0, 0x10, 0x86, 0xbf, 0xa4, 0x61,
	0x86, 0x17, 0x24, 0x20, 0xbf, 0xaf, 0x08, 0x17, 0xe8, 0x16, 0x34, 0x69, 0x8c, 0x43, 0xe2, 0x3a,
	0xbb, 0xce, 0x41, 0x37, 0xd0, 0x82, 0xbf, 0x0b, 0x7d, 0xcb, 0x4b, 0xa3, 0x35, 0xda, 0x84, 0x3a,
	0x9e, 0x9f, 0x1b, 0x8e, 0x5c, 0xfa, 0x47, 0xb0, 0x39, 0x21, 0xd9, 0x05, 0x9d, 0x93, 0x13, 0xca,
	0xb5, 0x39, 0x34, 0x82, 0x0e, 0xd7, 0x18, 0x77, 0x9d, 0xdd, 0xfa, 0x41, 0xef, 0x10, 0x69, 0x2f,
	0x47, 0x86, 0xfa, 0x3a, 0x39, 0x63, 0x81, 0xe5, 0xf8, 0x7f, 0x3b, 0xd0, 0x2b, 0xec, 0xa0, 0x21,
	0xd4, 0xe8, 0xc2, 0x18, 0xa9, 0xd1, 0x85, 0xf4, 0x8d, 0x0b, 0x2c, 0x88, 0x5b, 0xd3, 0xbe, 0x29,
	0x01, 0x3d, 0x86, 0x16, 0xb9, 0x20, 0x89, 0xe0, 0x6e, 0x7d, 0xd7, 0x39, 0xe8, 0x1d, 0xde, 0x2a,
	0xdb, 0x78, 0xa5, 0xf6, 0x02, 0xc3, 0x91, 0xec, 0x25, 0xc1, 0x91, 0x58, 0xba, 0x8d, 0xeb, 0xd8,
	0xdf, 0xab, 0xbd, 0xc0, 0x70, 0xfc, 0x6f, 0x60, 0x50, 0x52, 0x83, 0x3e, 0xb1, 0xc6, 0x74, 0x40,
	0xdb, 0xd7, 0x18, 0xcb, 0x6d, 0xf9, 0x33, 0xe8, 0x17, 0x71, 0x99, 0xb5, 0x98, 0x87, 0x79, 0xd6,
	0x62, 0x1e, 0x56, 0x44, 0xf4, 0x31, 0xd4, 0x6c, 0x34, 0xde, 0x48, 0xdf, 0xf8, 0x28, 0xbf, 0xf1,
	0xd1, 0xcf, 0xf9, 0x8d, 0x07, 0x35, 0xc1, 0xfd, 0x7f, 0x1c, 0xeb, 0xa2, 0xf6, 0x1d, 0xb9, 0xd0,
	0x5e, 0x25, 0xe7, 0x09, 0x7b, 0x9b, 0x28, 0x4b, 0x9d, 0x20, 0x17, 0xe5, 0x8e, 0x8e, 0x6b, 0xad,
	0xec, 0x75, 0x82, 0x5c, 0x44, 0xf7, 0xa1, 0x1f, 0x61, 0x2e, 0xa6, 0x31, 0xe1, 0x5c, 0x5e, 0x7e,
	0x5d, 0xb9, 0xd3, 0x93, 0xd8, 0x8f, 0x1a, 0x42, 0x5f, 0x83, 0x12, 0xa7, 0xf3, 0x25, 0x4e, 0x42,
	0x62, 0xb2, 0x77, 0x93, 0x77, 0x20, 0xe9, 0x2f, 0x15, 0xdb, 0xff, 0x08, 0xb6, 0x8d, 0x93, 0x13,
	0x81, 0x33, 0x91, 0x17, 0xdb, 0x95, 0x0b, 0xf6, 0xf7, 0x61, 0xab, 0x4c, 0x93, 0x55, 0x84, 0xa0,
	0x91, 0x11, 0x9e, 0x1a, 0x9a, 0x5a, 0xfb, 0x0f, 0x00, 0x59, 0x22, 0x4b, 0xab, 0xd4, 0x3d, 0xb4,
	0x35, 0xa9, 0x59, 0x55, 0xda, 0xf6, 0x61, 0xc7, 0xf0, 0x02, 0xe9, 0x7b, 0xb5, 0x7f, 0x8f, 0x6c,
	0x18, 0x96, 0x58, 0xa5, 0xd3, 0x87, 0xfe, 0x4d, 0xa1, 0x7e, 0x55, 0x73, 0x1d, 0xff, 0x01, 0xc0,
	0xcd, 0x71, 0x2a, 0xd6, 0x7d, 0xe8, 0xdd, 0x10, 0xa4, 0xa2, 0xec, 0x41, 0xf7, 0xc6, 0x08, 0x15,
	0xe9, 0x5b, 0x18, 0x4c, 0x44, 0x46, 0x70, 0x4c, 0x93, 0x70, 0x8c, 0x05, 0x96, 0xc5, 0x37, 0x5b,
	0x0b, 0xf5, 0x6f, 0x3a, 0x07, 0xfd, 0x40, 0x0b, 0xe8, 0x36, 0xb4, 0x48, 0x96, 0xb1, 0x8c, 0x9b,
	0x9a, 0x34, 0x92, 0xff, 0x29, 0x0c, 0x5f, 0xb2, 0x74, 0xfd, 0x66, 0x65, 0x43, 0xba, 0x03, 0xdd,
	0x8c, 0x31, 0x31, 0x4d, 0xb1, 0x58, 0x1a, 0x6b, 0x1d, 0x09, 0x9c, 0x62, 0xb1, 0xf4, 0x67, 0xd0,
	0x3d, 0x99, 0xe4, 0x4c, 0xe9, 0x12, 0x63, 0xc2, 0xba, 0xc4, 0x98, 0x90, 0xc5, 0x98, 0x91, 0xf9,
	0x2a, 0xe3, 0x24, 0x2f, 0x46, 0x23, 0xa2, 0x7d, 0xd8, 0xd0, 0x4b, 0xca, 0x92, 0xe9, 0x82, 0xa4,
	0x62, 0xa9, 0xea, 0xb1, 0x19, 0x0c, 0x2d, 0x3c, 0x96, 0xa8, 0xff, 0x9f, 0x03, 0x9d, 0x63, 0x1a,
	0xe9, 0x66, 0x81, 0xa0, 0x91, 0xe0, 0x38, 0xef, 0x5b, 0x6a, 0x2d, 0x31, 0x4e, 0xff, 0xd0, 0x06,
	0xea, 0x81, 0x5a, 0x4b, 0x2c, 0x66, 0x0b, 0x5d, 0xe2, 0x83, 0x40, 0xad, 0x91, 0x07, 0x9d, 0x98,
	0x2d, 0xe8, 0x19, 0x25, 0x0b, 0x55, 0xd8, 0xf5, 0xc0, 0xca, 0x68, 0x07, 0x5a, 0x94, 0x4f, 0x17,
	0x34, 0x73, 0x9b, 0xca, 0xcd, 0x26, 0xe5, 0x63, 0x9a, 0xc9, 0xe4, 0xa9, 0xc4, 0xb8, 0x2d, 0xfd,
	0xe7, 0x2a, 0x41, 0x2a, 0x8f, 0x68, 0x72, 0xee, 0xb6, 0xb5, 0x13, 0x72, 0x8d, 0xf6, 0x60, 0x90,
	0x91, 0x08, 0x0b, 0x7a, 0x41, 0xa6, 0xca, 0xc3, 0x8e, 0xda, 0xec, 0xe7, 0xe0, 0x4f, 0x38, 0x26,
	0xfe, 0x08, 0xda, 0xe3, 0x63, 0x7d, 0x7f, 0x7b, 0xba, 0x27, 0xe4, 0x1d, 0x66, 0x60, 0x3a, 0xcc,
	0xf8, 0x78, 0x22, 0xb0, 0xd0, 0x2d, 0x82, 0xfb, 0x6b, 0x68, 0x69, 0x00, 0xdd, 0x03, 0x38, 0xa3,
	0x11, 0xe1, 0x6b, 0x2e, 0x48, 0x6c, 0xa2, 0x2f, 0x20, 0xa5, 0x1c, 0x34, 0x4c, 0x0e, 0xee, 0x42,
	0x17, 0x5f, 0x60, 0x1a, 0xe1, 0x59, 0xa4, 0x13, 0xd1, 0x08, 0x2e, 0x01, 0xf4, 0x01, 0x40, 0xcc,
	0x56, 0x89, 0x20, 0x8b, 0x29, 0x4b, 0x54, 0x3e, 0xba, 0x41, 0xd7, 0x20, 0x6f, 0x12, 0xff, 0x2f,
	0x07, 0xfa, 0xbf, 0x12, 0x75, 0x0d, 0x76, 0x18, 0x08, 0x6c, 0xdb, 0x9a, 0xc0, 0xa1, 0x44, 0xf8,
	0x12, 0x9b, 0x02, 0x92, 0x4b, 0x55, 0x6b, 0x2b, 0x1a, 0x09, 0xd3, 0x59, 0xb4, 0x20, 0x2d, 0x85,
	0x6c, 0x7a, 0xa1, 0x95, 0xe5, 0x96, 0x42, 0x66, 0xb4, 0xcb, 0x52, 0x67, 0x5c, 0xa5, 0xbd, 0x1b,
	0xd4, 0x18, 0x97, 0xa1, 0xe0, 0x6c, 0xbe, 0x34, 0x29, 0x57, 0xeb, 0xc3, 0x7f, 0x5b, 0xd0, 0x78,
	0x9d, 0x50, 0x81, 0x9e, 0x43, 0xdb, 0xd4, 0x27, 0xda, 0x31, 0x29, 0x2b, 0xd7, 0xab, 0x67, 0x5b,
	0x7d, 0xf1, 0x2f, 0x78, 0xea, 0xa0, 0xc7, 0x50, 0x1b, 0x1f, 0xa3, 0xdb, 0xef, 0xb4, 0xb2, 0x57,
	0x72, 0xee, 0x7a, 0x43, 0x9b, 0x7f, 0x1d, 0xed, 0x23, 0xa8, 0x9d, 0x4c, 0xd0, 0xa6, 0x41, 0x6d,
	0x8d, 0x7b, 0x1b, 0x06, 0xc9, 0x0b, 0xf2, 0xa9, 0x83, 0x9e, 0x41, 0x4b, 0xcf, 0xe2, 0x4a, 0xe5,
	0xf9, 0x3c, 0x2c, 0x8c, 0x6c, 0x74, 0x08, 0x4d, 0x35, 0xb2, 0x2b, 0x0f, 0x6d, 0xd9, 0x43, 0xf9,
	0x60, 0x47, 0xcf, 0xa1, 0x93, 0x0f, 0xf6, 0xca, 0x63, 0x36, 0xfc, 0xe2, 0x0b, 0x00, 0x7d, 0x01,
	0x6d, 0x33, 0xd9, 0x6d, 0xda, 0xca, 0x2f, 0x02, 0x6f, 0xfb, 0x2a, 0x2c, 0x8f, 0x7d, 0x67, 0x27,
	0xb5, 0x1c, 0xf7, 0x95, 0x36, 0xdf, 0x2b, 0x8f, 0xc7, 0xcb, 0xa7, 0xc1, 0xd8, 0x8e, 0x46, 0xd5,
	0x01, 0x91, 0x57, 0x26, 0x16, 0x5b, 0xa7, 0xe7, 0x5e, 0xbb, 0x27, 0xb5, 0xbc, 0xb0, 0x5e, 0xc8,
	0xf6, 0x87, 0xde, 0xbf, 0x4a, 0xb4, 0x5d, 0xf3, 0xaa, 0x23, 0x97, 0xdd, 0xf2, 0x07, 0x18, 0x96,
	0x5b, 0x3a, 0xba, 0x5b, 0xa6, 0x96, 0x47, 0x82, 0xe7, 0x55, 0xec, 0x4a, 0x5d, 0xcf, 0xa0, 0xa9,
	0xa3, 0xb1, 0xaf, 0x82, 0xe2, 0xc9, 0xad, 0x32, 0x28, 0x9f, 0x5f, 0xf5, 0x3f, 0x6b, 0x0e, 0xfa,
	0x0c, 0x1a, 0xca, 0x7b, 0xfb, 0x36, 0x2a, 0xb8, 0xbd, 0x59, 0xc2, 0xec, 0x91, 0x2f, 0xa1, 0x9d,
	0xff, 0x23, 0x55, 0x99, 0xcf, 0x5d, 0x28, 0xfe, 0xa9, 0x47, 0xf7, 0xa0, 0x3b, 0x67, 0xb1, 0xde,
	0x39, 0xea, 0xbc, 0x48, 0xe9, 0xa9, 0x5c, 0x9d, 0x3a, 0xbf, 0xe9, 0xa7, 0xe7, 0xac, 0xa5, 0x3e,
	0x9f, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x84, 0x80, 0x11, 0x12, 0x95, 0x0a, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// InitClient is the client API for Init service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type InitClient interface {
	CopyOut(ctx context.Context, in *CopyOutRequest, opts ...grpc.CallOption) (Init_CopyOutClient, error)
	DF(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*DFReply, error)
	LS(ctx context.Context, in *LSRequest, opts ...grpc.CallOption) (Init_LSClient, error)
	Reboot(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*RebootReply, error)
	Reset(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ResetReply, error)
	Shutdown(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ShutdownReply, error)
	Upgrade(ctx context.Context, in *UpgradeRequest, opts ...grpc.CallOption) (*UpgradeReply, error)
	ServiceList(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ServiceListReply, error)
	ServiceStart(ctx context.Context, in *ServiceStartRequest, opts ...grpc.CallOption) (*ServiceStartReply, error)
	ServiceStop(ctx context.Context, in *ServiceStopRequest, opts ...grpc.CallOption) (*ServiceStopReply, error)
	ServiceRestart(ctx context.Context, in *ServiceRestartRequest, opts ...grpc.CallOption) (*ServiceRestartReply, error)
	Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartReply, error)
	Stop(ctx context.Context, in *StopRequest, opts ...grpc.CallOption) (*StopReply, error)
	Version(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*VersionReply, error)
}

type initClient struct {
	cc *grpc.ClientConn
}

func NewInitClient(cc *grpc.ClientConn) InitClient {
	return &initClient{cc}
}

func (c *initClient) CopyOut(ctx context.Context, in *CopyOutRequest, opts ...grpc.CallOption) (Init_CopyOutClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Init_serviceDesc.Streams[0], "/proto.Init/CopyOut", opts...)
	if err != nil {
		return nil, err
	}
	x := &initCopyOutClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Init_CopyOutClient interface {
	Recv() (*StreamingData, error)
	grpc.ClientStream
}

type initCopyOutClient struct {
	grpc.ClientStream
}

func (x *initCopyOutClient) Recv() (*StreamingData, error) {
	m := new(StreamingData)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *initClient) DF(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*DFReply, error) {
	out := new(DFReply)
	err := c.cc.Invoke(ctx, "/proto.Init/DF", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *initClient) LS(ctx context.Context, in *LSRequest, opts ...grpc.CallOption) (Init_LSClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Init_serviceDesc.Streams[1], "/proto.Init/LS", opts...)
	if err != nil {
		return nil, err
	}
	x := &initLSClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Init_LSClient interface {
	Recv() (*FileInfo, error)
	grpc.ClientStream
}

type initLSClient struct {
	grpc.ClientStream
}

func (x *initLSClient) Recv() (*FileInfo, error) {
	m := new(FileInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *initClient) Reboot(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*RebootReply, error) {
	out := new(RebootReply)
	err := c.cc.Invoke(ctx, "/proto.Init/Reboot", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *initClient) Reset(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ResetReply, error) {
	out := new(ResetReply)
	err := c.cc.Invoke(ctx, "/proto.Init/Reset", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *initClient) Shutdown(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ShutdownReply, error) {
	out := new(ShutdownReply)
	err := c.cc.Invoke(ctx, "/proto.Init/Shutdown", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *initClient) Upgrade(ctx context.Context, in *UpgradeRequest, opts ...grpc.CallOption) (*UpgradeReply, error) {
	out := new(UpgradeReply)
	err := c.cc.Invoke(ctx, "/proto.Init/Upgrade", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *initClient) ServiceList(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ServiceListReply, error) {
	out := new(ServiceListReply)
	err := c.cc.Invoke(ctx, "/proto.Init/ServiceList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *initClient) ServiceStart(ctx context.Context, in *ServiceStartRequest, opts ...grpc.CallOption) (*ServiceStartReply, error) {
	out := new(ServiceStartReply)
	err := c.cc.Invoke(ctx, "/proto.Init/ServiceStart", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *initClient) ServiceStop(ctx context.Context, in *ServiceStopRequest, opts ...grpc.CallOption) (*ServiceStopReply, error) {
	out := new(ServiceStopReply)
	err := c.cc.Invoke(ctx, "/proto.Init/ServiceStop", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *initClient) ServiceRestart(ctx context.Context, in *ServiceRestartRequest, opts ...grpc.CallOption) (*ServiceRestartReply, error) {
	out := new(ServiceRestartReply)
	err := c.cc.Invoke(ctx, "/proto.Init/ServiceRestart", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *initClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartReply, error) {
	out := new(StartReply)
	err := c.cc.Invoke(ctx, "/proto.Init/Start", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *initClient) Stop(ctx context.Context, in *StopRequest, opts ...grpc.CallOption) (*StopReply, error) {
	out := new(StopReply)
	err := c.cc.Invoke(ctx, "/proto.Init/Stop", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *initClient) Version(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*VersionReply, error) {
	out := new(VersionReply)
	err := c.cc.Invoke(ctx, "/proto.Init/Version", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// InitServer is the server API for Init service.
type InitServer interface {
	CopyOut(*CopyOutRequest, Init_CopyOutServer) error
	DF(context.Context, *empty.Empty) (*DFReply, error)
	LS(*LSRequest, Init_LSServer) error
	Reboot(context.Context, *empty.Empty) (*RebootReply, error)
	Reset(context.Context, *empty.Empty) (*ResetReply, error)
	Shutdown(context.Context, *empty.Empty) (*ShutdownReply, error)
	Upgrade(context.Context, *UpgradeRequest) (*UpgradeReply, error)
	ServiceList(context.Context, *empty.Empty) (*ServiceListReply, error)
	ServiceStart(context.Context, *ServiceStartRequest) (*ServiceStartReply, error)
	ServiceStop(context.Context, *ServiceStopRequest) (*ServiceStopReply, error)
	ServiceRestart(context.Context, *ServiceRestartRequest) (*ServiceRestartReply, error)
	Start(context.Context, *StartRequest) (*StartReply, error)
	Stop(context.Context, *StopRequest) (*StopReply, error)
	Version(context.Context, *empty.Empty) (*VersionReply, error)
}

func RegisterInitServer(s *grpc.Server, srv InitServer) {
	s.RegisterService(&_Init_serviceDesc, srv)
}

func _Init_CopyOut_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CopyOutRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InitServer).CopyOut(m, &initCopyOutServer{stream})
}

type Init_CopyOutServer interface {
	Send(*StreamingData) error
	grpc.ServerStream
}

type initCopyOutServer struct {
	grpc.ServerStream
}

func (x *initCopyOutServer) Send(m *StreamingData) error {
	return x.ServerStream.SendMsg(m)
}

func _Init_DF_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).DF(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/DF",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).DF(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Init_LS_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LSRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(InitServer).LS(m, &initLSServer{stream})
}

type Init_LSServer interface {
	Send(*FileInfo) error
	grpc.ServerStream
}

type initLSServer struct {
	grpc.ServerStream
}

func (x *initLSServer) Send(m *FileInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _Init_Reboot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).Reboot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/Reboot",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).Reboot(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Init_Reset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).Reset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/Reset",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).Reset(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Init_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).Shutdown(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/Shutdown",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).Shutdown(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Init_Upgrade_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpgradeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).Upgrade(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/Upgrade",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).Upgrade(ctx, req.(*UpgradeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Init_ServiceList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).ServiceList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/ServiceList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).ServiceList(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Init_ServiceStart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServiceStartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).ServiceStart(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/ServiceStart",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).ServiceStart(ctx, req.(*ServiceStartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Init_ServiceStop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServiceStopRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).ServiceStop(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/ServiceStop",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).ServiceStop(ctx, req.(*ServiceStopRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Init_ServiceRestart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServiceRestartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).ServiceRestart(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/ServiceRestart",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).ServiceRestart(ctx, req.(*ServiceRestartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Init_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).Start(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/Start",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).Start(ctx, req.(*StartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Init_Stop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StopRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).Stop(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/Stop",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).Stop(ctx, req.(*StopRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Init_Version_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InitServer).Version(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Init/Version",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InitServer).Version(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

var _Init_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.Init",
	HandlerType: (*InitServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DF",
			Handler:    _Init_DF_Handler,
		},
		{
			MethodName: "Reboot",
			Handler:    _Init_Reboot_Handler,
		},
		{
			MethodName: "Reset",
			Handler:    _Init_Reset_Handler,
		},
		{
			MethodName: "Shutdown",
			Handler:    _Init_Shutdown_Handler,
		},
		{
			MethodName: "Upgrade",
			Handler:    _Init_Upgrade_Handler,
		},
		{
			MethodName: "ServiceList",
			Handler:    _Init_ServiceList_Handler,
		},
		{
			MethodName: "ServiceStart",
			Handler:    _Init_ServiceStart_Handler,
		},
		{
			MethodName: "ServiceStop",
			Handler:    _Init_ServiceStop_Handler,
		},
		{
			MethodName: "ServiceRestart",
			Handler:    _Init_ServiceRestart_Handler,
		},
		{
			MethodName: "Start",
			Handler:    _Init_Start_Handler,
		},
		{
			MethodName: "Stop",
			Handler:    _Init_Stop_Handler,
		},
		{
			MethodName: "Version",
			Handler:    _Init_Version_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "CopyOut",
			Handler:       _Init_CopyOut_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "LS",
			Handler:       _Init_LS_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api.proto",
}