ems_grpc.pb.go

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

/*
Package IOSXRExtensibleManagabilityService is a generated protocol buffer package.

Package implements gRPC Model Driven Telemetry service

It is generated from these files:
	ems_grpc.proto

It has these top-level messages:
	ConfigGetArgs
	ConfigGetReply
	GetOperArgs
	GetOperReply
	ConfigArgs
	ConfigReply
	CliConfigArgs
	CliConfigReply
	CommitReplaceArgs
	CommitReplaceReply
	CommitMsg
	CommitArgs
	CommitReply
	DiscardChangesArgs
	DiscardChangesReply
	ShowCmdArgs
	ShowCmdTextReply
	ShowCmdJSONReply
	CreateSubsArgs
	CreateSubsReply
	ActionJSONArgs
	ActionJSONReply
*/
package IOSXRExtensibleManagabilityService

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import (
	context "golang.org/x/net/context"
	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.ProtoPackageIsVersion2 // please upgrade the proto package

type CommitResult int32

const (
	CommitResult_CHANGE    CommitResult = 0
	CommitResult_NO_CHANGE CommitResult = 1
	CommitResult_FAIL      CommitResult = 2
)

var CommitResult_name = map[int32]string{
	0: "CHANGE",
	1: "NO_CHANGE",
	2: "FAIL",
}
var CommitResult_value = map[string]int32{
	"CHANGE":    0,
	"NO_CHANGE": 1,
	"FAIL":      2,
}

func (x CommitResult) String() string {
	return proto.EnumName(CommitResult_name, int32(x))
}
func (CommitResult) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

type ConfigGetArgs struct {
	ReqId        int64  `protobuf:"varint,1,opt,name=ReqId" json:"ReqId,omitempty"`
	Yangpathjson string `protobuf:"bytes,2,opt,name=yangpathjson" json:"yangpathjson,omitempty"`
}

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

func (m *ConfigGetArgs) GetReqId() int64 {
	if m != nil {
		return m.ReqId
	}
	return 0
}

func (m *ConfigGetArgs) GetYangpathjson() string {
	if m != nil {
		return m.Yangpathjson
	}
	return ""
}

type ConfigGetReply struct {
	ResReqId int64  `protobuf:"varint,1,opt,name=ResReqId" json:"ResReqId,omitempty"`
	Yangjson string `protobuf:"bytes,2,opt,name=yangjson" json:"yangjson,omitempty"`
	Errors   string `protobuf:"bytes,3,opt,name=errors" json:"errors,omitempty"`
}

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

func (m *ConfigGetReply) GetResReqId() int64 {
	if m != nil {
		return m.ResReqId
	}
	return 0
}

func (m *ConfigGetReply) GetYangjson() string {
	if m != nil {
		return m.Yangjson
	}
	return ""
}

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

type GetOperArgs struct {
	ReqId        int64  `protobuf:"varint,1,opt,name=ReqId" json:"ReqId,omitempty"`
	Yangpathjson string `protobuf:"bytes,2,opt,name=yangpathjson" json:"yangpathjson,omitempty"`
}

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

func (m *GetOperArgs) GetReqId() int64 {
	if m != nil {
		return m.ReqId
	}
	return 0
}

func (m *GetOperArgs) GetYangpathjson() string {
	if m != nil {
		return m.Yangpathjson
	}
	return ""
}

type GetOperReply struct {
	ResReqId int64  `protobuf:"varint,1,opt,name=ResReqId" json:"ResReqId,omitempty"`
	Yangjson string `protobuf:"bytes,2,opt,name=yangjson" json:"yangjson,omitempty"`
	Errors   string `protobuf:"bytes,3,opt,name=errors" json:"errors,omitempty"`
}

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

func (m *GetOperReply) GetResReqId() int64 {
	if m != nil {
		return m.ResReqId
	}
	return 0
}

func (m *GetOperReply) GetYangjson() string {
	if m != nil {
		return m.Yangjson
	}
	return ""
}

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

type ConfigArgs struct {
	ReqId    int64  `protobuf:"varint,1,opt,name=ReqId" json:"ReqId,omitempty"`
	Yangjson string `protobuf:"bytes,2,opt,name=yangjson" json:"yangjson,omitempty"`
}

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

func (m *ConfigArgs) GetReqId() int64 {
	if m != nil {
		return m.ReqId
	}
	return 0
}

func (m *ConfigArgs) GetYangjson() string {
	if m != nil {
		return m.Yangjson
	}
	return ""
}

type ConfigReply struct {
	ResReqId int64  `protobuf:"varint,1,opt,name=ResReqId" json:"ResReqId,omitempty"`
	Errors   string `protobuf:"bytes,2,opt,name=errors" json:"errors,omitempty"`
}

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

func (m *ConfigReply) GetResReqId() int64 {
	if m != nil {
		return m.ResReqId
	}
	return 0
}

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

type CliConfigArgs struct {
	ReqId int64  `protobuf:"varint,1,opt,name=ReqId" json:"ReqId,omitempty"`
	Cli   string `protobuf:"bytes,2,opt,name=cli" json:"cli,omitempty"`
}

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

func (m *CliConfigArgs) GetReqId() int64 {
	if m != nil {
		return m.ReqId
	}
	return 0
}

func (m *CliConfigArgs) GetCli() string {
	if m != nil {
		return m.Cli
	}
	return ""
}

type CliConfigReply struct {
	ResReqId int64  `protobuf:"varint,1,opt,name=ResReqId" json:"ResReqId,omitempty"`
	Errors   string `protobuf:"bytes,2,opt,name=errors" json:"errors,omitempty"`
}

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

func (m *CliConfigReply) GetResReqId() int64 {
	if m != nil {
		return m.ResReqId
	}
	return 0
}

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

type CommitReplaceArgs struct {
	ReqId    int64  `protobuf:"varint,1,opt,name=ReqId" json:"ReqId,omitempty"`
	Cli      string `protobuf:"bytes,2,opt,name=cli" json:"cli,omitempty"`
	Yangjson string `protobuf:"bytes,3,opt,name=yangjson" json:"yangjson,omitempty"`
}

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

func (m *CommitReplaceArgs) GetReqId() int64 {
	if m != nil {
		return m.ReqId
	}
	return 0
}

func (m *CommitReplaceArgs) GetCli() string {
	if m != nil {
		return m.Cli
	}
	return ""
}

func (m *CommitReplaceArgs) GetYangjson() string {
	if m != nil {
		return m.Yangjson
	}
	return ""
}

type CommitReplaceReply struct {
	ResReqId int64  `protobuf:"varint,1,opt,name=ResReqId" json:"ResReqId,omitempty"`
	Errors   string `protobuf:"bytes,2,opt,name=errors" json:"errors,omitempty"`
}

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

func (m *CommitReplaceReply) GetResReqId() int64 {
	if m != nil {
		return m.ResReqId
	}
	return 0
}

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

type CommitMsg struct {
	Label   string `protobuf:"bytes,1,opt,name=label" json:"label,omitempty"`
	Comment string `protobuf:"bytes,2,opt,name=comment" json:"comment,omitempty"`
}

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

func (m *CommitMsg) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

func (m *CommitMsg) GetComment() string {
	if m != nil {
		return m.Comment
	}
	return ""
}

type CommitArgs struct {
	Msg   *CommitMsg `protobuf:"bytes,1,opt,name=msg" json:"msg,omitempty"`
	ReqId int64      `protobuf:"varint,2,opt,name=ReqId" json:"ReqId,omitempty"`
}

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

func (m *CommitArgs) GetMsg() *CommitMsg {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *CommitArgs) GetReqId() int64 {
	if m != nil {
		return m.ReqId
	}
	return 0
}

type CommitReply struct {
	Result   CommitResult `protobuf:"varint,1,opt,name=result,enum=IOSXRExtensibleManagabilityService.CommitResult" json:"result,omitempty"`
	ResReqId int64        `protobuf:"varint,2,opt,name=ResReqId" json:"ResReqId,omitempty"`
	Errors   string       `protobuf:"bytes,3,opt,name=errors" json:"errors,omitempty"`
}

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

func (m *CommitReply) GetResult() CommitResult {
	if m != nil {
		return m.Result
	}
	return CommitResult_CHANGE
}

func (m *CommitReply) GetResReqId() int64 {
	if m != nil {
		return m.ResReqId
	}
	return 0
}

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

type DiscardChangesArgs struct {
	ReqId int64 `protobuf:"varint,1,opt,name=ReqId" json:"ReqId,omitempty"`
}

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

func (m *DiscardChangesArgs) GetReqId() int64 {
	if m != nil {
		return m.ReqId
	}
	return 0
}

type DiscardChangesReply struct {
	ResReqId int64  `protobuf:"varint,1,opt,name=ResReqId" json:"ResReqId,omitempty"`
	Errors   string `protobuf:"bytes,2,opt,name=errors" json:"errors,omitempty"`
}

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

func (m *DiscardChangesReply) GetResReqId() int64 {
	if m != nil {
		return m.ResReqId
	}
	return 0
}

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

type ShowCmdArgs struct {
	ReqId int64  `protobuf:"varint,1,opt,name=ReqId" json:"ReqId,omitempty"`
	Cli   string `protobuf:"bytes,2,opt,name=cli" json:"cli,omitempty"`
}

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

func (m *ShowCmdArgs) GetReqId() int64 {
	if m != nil {
		return m.ReqId
	}
	return 0
}

func (m *ShowCmdArgs) GetCli() string {
	if m != nil {
		return m.Cli
	}
	return ""
}

type ShowCmdTextReply struct {
	ResReqId int64  `protobuf:"varint,1,opt,name=ResReqId" json:"ResReqId,omitempty"`
	Output   string `protobuf:"bytes,2,opt,name=output" json:"output,omitempty"`
	Errors   string `protobuf:"bytes,3,opt,name=errors" json:"errors,omitempty"`
}

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

func (m *ShowCmdTextReply) GetResReqId() int64 {
	if m != nil {
		return m.ResReqId
	}
	return 0
}

func (m *ShowCmdTextReply) GetOutput() string {
	if m != nil {
		return m.Output
	}
	return ""
}

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

type ShowCmdJSONReply struct {
	ResReqId   int64  `protobuf:"varint,1,opt,name=ResReqId" json:"ResReqId,omitempty"`
	Jsonoutput string `protobuf:"bytes,2,opt,name=jsonoutput" json:"jsonoutput,omitempty"`
	Errors     string `protobuf:"bytes,3,opt,name=errors" json:"errors,omitempty"`
}

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

func (m *ShowCmdJSONReply) GetResReqId() int64 {
	if m != nil {
		return m.ResReqId
	}
	return 0
}

func (m *ShowCmdJSONReply) GetJsonoutput() string {
	if m != nil {
		return m.Jsonoutput
	}
	return ""
}

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

type CreateSubsArgs struct {
	ReqId    int64  `protobuf:"varint,1,opt,name=ReqId" json:"ReqId,omitempty"`
	Encode   int64  `protobuf:"varint,2,opt,name=encode" json:"encode,omitempty"`
	Subidstr string `protobuf:"bytes,3,opt,name=subidstr" json:"subidstr,omitempty"`
}

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

func (m *CreateSubsArgs) GetReqId() int64 {
	if m != nil {
		return m.ReqId
	}
	return 0
}

func (m *CreateSubsArgs) GetEncode() int64 {
	if m != nil {
		return m.Encode
	}
	return 0
}

func (m *CreateSubsArgs) GetSubidstr() string {
	if m != nil {
		return m.Subidstr
	}
	return ""
}

type CreateSubsReply struct {
	ResReqId int64  `protobuf:"varint,1,opt,name=ResReqId" json:"ResReqId,omitempty"`
	Data     []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	Errors   string `protobuf:"bytes,3,opt,name=errors" json:"errors,omitempty"`
}

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

func (m *CreateSubsReply) GetResReqId() int64 {
	if m != nil {
		return m.ResReqId
	}
	return 0
}

func (m *CreateSubsReply) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

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

type ActionJSONArgs struct {
	ReqId        int64  `protobuf:"varint,1,opt,name=ReqId" json:"ReqId,omitempty"`
	Yangpathjson string `protobuf:"bytes,2,opt,name=yangpathjson" json:"yangpathjson,omitempty"`
}

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

func (m *ActionJSONArgs) GetReqId() int64 {
	if m != nil {
		return m.ReqId
	}
	return 0
}

func (m *ActionJSONArgs) GetYangpathjson() string {
	if m != nil {
		return m.Yangpathjson
	}
	return ""
}

type ActionJSONReply struct {
	ResReqId int64  `protobuf:"varint,1,opt,name=ResReqId" json:"ResReqId,omitempty"`
	Yangjson string `protobuf:"bytes,2,opt,name=yangjson" json:"yangjson,omitempty"`
	Errors   string `protobuf:"bytes,3,opt,name=errors" json:"errors,omitempty"`
}

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

func (m *ActionJSONReply) GetResReqId() int64 {
	if m != nil {
		return m.ResReqId
	}
	return 0
}

func (m *ActionJSONReply) GetYangjson() string {
	if m != nil {
		return m.Yangjson
	}
	return ""
}

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

func init() {
	proto.RegisterType((*ConfigGetArgs)(nil), "IOSXRExtensibleManagabilityService.ConfigGetArgs")
	proto.RegisterType((*ConfigGetReply)(nil), "IOSXRExtensibleManagabilityService.ConfigGetReply")
	proto.RegisterType((*GetOperArgs)(nil), "IOSXRExtensibleManagabilityService.GetOperArgs")
	proto.RegisterType((*GetOperReply)(nil), "IOSXRExtensibleManagabilityService.GetOperReply")
	proto.RegisterType((*ConfigArgs)(nil), "IOSXRExtensibleManagabilityService.ConfigArgs")
	proto.RegisterType((*ConfigReply)(nil), "IOSXRExtensibleManagabilityService.ConfigReply")
	proto.RegisterType((*CliConfigArgs)(nil), "IOSXRExtensibleManagabilityService.CliConfigArgs")
	proto.RegisterType((*CliConfigReply)(nil), "IOSXRExtensibleManagabilityService.CliConfigReply")
	proto.RegisterType((*CommitReplaceArgs)(nil), "IOSXRExtensibleManagabilityService.CommitReplaceArgs")
	proto.RegisterType((*CommitReplaceReply)(nil), "IOSXRExtensibleManagabilityService.CommitReplaceReply")
	proto.RegisterType((*CommitMsg)(nil), "IOSXRExtensibleManagabilityService.CommitMsg")
	proto.RegisterType((*CommitArgs)(nil), "IOSXRExtensibleManagabilityService.CommitArgs")
	proto.RegisterType((*CommitReply)(nil), "IOSXRExtensibleManagabilityService.CommitReply")
	proto.RegisterType((*DiscardChangesArgs)(nil), "IOSXRExtensibleManagabilityService.DiscardChangesArgs")
	proto.RegisterType((*DiscardChangesReply)(nil), "IOSXRExtensibleManagabilityService.DiscardChangesReply")
	proto.RegisterType((*ShowCmdArgs)(nil), "IOSXRExtensibleManagabilityService.ShowCmdArgs")
	proto.RegisterType((*ShowCmdTextReply)(nil), "IOSXRExtensibleManagabilityService.ShowCmdTextReply")
	proto.RegisterType((*ShowCmdJSONReply)(nil), "IOSXRExtensibleManagabilityService.ShowCmdJSONReply")
	proto.RegisterType((*CreateSubsArgs)(nil), "IOSXRExtensibleManagabilityService.CreateSubsArgs")
	proto.RegisterType((*CreateSubsReply)(nil), "IOSXRExtensibleManagabilityService.CreateSubsReply")
	proto.RegisterType((*ActionJSONArgs)(nil), "IOSXRExtensibleManagabilityService.ActionJSONArgs")
	proto.RegisterType((*ActionJSONReply)(nil), "IOSXRExtensibleManagabilityService.ActionJSONReply")
	proto.RegisterEnum("IOSXRExtensibleManagabilityService.CommitResult", CommitResult_name, CommitResult_value)
}

// 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

// Client API for GRPCConfigOper service

type GRPCConfigOperClient interface {
	GetConfig(ctx context.Context, in *ConfigGetArgs, opts ...grpc.CallOption) (GRPCConfigOper_GetConfigClient, error)
	MergeConfig(ctx context.Context, in *ConfigArgs, opts ...grpc.CallOption) (*ConfigReply, error)
	DeleteConfig(ctx context.Context, in *ConfigArgs, opts ...grpc.CallOption) (*ConfigReply, error)
	ReplaceConfig(ctx context.Context, in *ConfigArgs, opts ...grpc.CallOption) (*ConfigReply, error)
	CliConfig(ctx context.Context, in *CliConfigArgs, opts ...grpc.CallOption) (*CliConfigReply, error)
	CommitReplace(ctx context.Context, in *CommitReplaceArgs, opts ...grpc.CallOption) (*CommitReplaceReply, error)
	// Do we need implicit or explicit commit
	//
	CommitConfig(ctx context.Context, in *CommitArgs, opts ...grpc.CallOption) (*CommitReply, error)
	ConfigDiscardChanges(ctx context.Context, in *DiscardChangesArgs, opts ...grpc.CallOption) (*DiscardChangesReply, error)
	// Get only returns oper data
	//
	GetOper(ctx context.Context, in *GetOperArgs, opts ...grpc.CallOption) (GRPCConfigOper_GetOperClient, error)
	// Get Telemetry Data
	CreateSubs(ctx context.Context, in *CreateSubsArgs, opts ...grpc.CallOption) (GRPCConfigOper_CreateSubsClient, error)
}

type gRPCConfigOperClient struct {
	cc *grpc.ClientConn
}

func NewGRPCConfigOperClient(cc *grpc.ClientConn) GRPCConfigOperClient {
	return &gRPCConfigOperClient{cc}
}

func (c *gRPCConfigOperClient) GetConfig(ctx context.Context, in *ConfigGetArgs, opts ...grpc.CallOption) (GRPCConfigOper_GetConfigClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_GRPCConfigOper_serviceDesc.Streams[0], c.cc, "/IOSXRExtensibleManagabilityService.gRPCConfigOper/GetConfig", opts...)
	if err != nil {
		return nil, err
	}
	x := &gRPCConfigOperGetConfigClient{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 GRPCConfigOper_GetConfigClient interface {
	Recv() (*ConfigGetReply, error)
	grpc.ClientStream
}

type gRPCConfigOperGetConfigClient struct {
	grpc.ClientStream
}

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

func (c *gRPCConfigOperClient) MergeConfig(ctx context.Context, in *ConfigArgs, opts ...grpc.CallOption) (*ConfigReply, error) {
	out := new(ConfigReply)
	err := grpc.Invoke(ctx, "/IOSXRExtensibleManagabilityService.gRPCConfigOper/MergeConfig", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gRPCConfigOperClient) DeleteConfig(ctx context.Context, in *ConfigArgs, opts ...grpc.CallOption) (*ConfigReply, error) {
	out := new(ConfigReply)
	err := grpc.Invoke(ctx, "/IOSXRExtensibleManagabilityService.gRPCConfigOper/DeleteConfig", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gRPCConfigOperClient) ReplaceConfig(ctx context.Context, in *ConfigArgs, opts ...grpc.CallOption) (*ConfigReply, error) {
	out := new(ConfigReply)
	err := grpc.Invoke(ctx, "/IOSXRExtensibleManagabilityService.gRPCConfigOper/ReplaceConfig", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gRPCConfigOperClient) CliConfig(ctx context.Context, in *CliConfigArgs, opts ...grpc.CallOption) (*CliConfigReply, error) {
	out := new(CliConfigReply)
	err := grpc.Invoke(ctx, "/IOSXRExtensibleManagabilityService.gRPCConfigOper/CliConfig", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gRPCConfigOperClient) CommitReplace(ctx context.Context, in *CommitReplaceArgs, opts ...grpc.CallOption) (*CommitReplaceReply, error) {
	out := new(CommitReplaceReply)
	err := grpc.Invoke(ctx, "/IOSXRExtensibleManagabilityService.gRPCConfigOper/CommitReplace", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gRPCConfigOperClient) CommitConfig(ctx context.Context, in *CommitArgs, opts ...grpc.CallOption) (*CommitReply, error) {
	out := new(CommitReply)
	err := grpc.Invoke(ctx, "/IOSXRExtensibleManagabilityService.gRPCConfigOper/CommitConfig", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gRPCConfigOperClient) ConfigDiscardChanges(ctx context.Context, in *DiscardChangesArgs, opts ...grpc.CallOption) (*DiscardChangesReply, error) {
	out := new(DiscardChangesReply)
	err := grpc.Invoke(ctx, "/IOSXRExtensibleManagabilityService.gRPCConfigOper/ConfigDiscardChanges", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gRPCConfigOperClient) GetOper(ctx context.Context, in *GetOperArgs, opts ...grpc.CallOption) (GRPCConfigOper_GetOperClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_GRPCConfigOper_serviceDesc.Streams[1], c.cc, "/IOSXRExtensibleManagabilityService.gRPCConfigOper/GetOper", opts...)
	if err != nil {
		return nil, err
	}
	x := &gRPCConfigOperGetOperClient{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 GRPCConfigOper_GetOperClient interface {
	Recv() (*GetOperReply, error)
	grpc.ClientStream
}

type gRPCConfigOperGetOperClient struct {
	grpc.ClientStream
}

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

func (c *gRPCConfigOperClient) CreateSubs(ctx context.Context, in *CreateSubsArgs, opts ...grpc.CallOption) (GRPCConfigOper_CreateSubsClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_GRPCConfigOper_serviceDesc.Streams[2], c.cc, "/IOSXRExtensibleManagabilityService.gRPCConfigOper/CreateSubs", opts...)
	if err != nil {
		return nil, err
	}
	x := &gRPCConfigOperCreateSubsClient{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 GRPCConfigOper_CreateSubsClient interface {
	Recv() (*CreateSubsReply, error)
	grpc.ClientStream
}

type gRPCConfigOperCreateSubsClient struct {
	grpc.ClientStream
}

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

// Server API for GRPCConfigOper service

type GRPCConfigOperServer interface {
	GetConfig(*ConfigGetArgs, GRPCConfigOper_GetConfigServer) error
	MergeConfig(context.Context, *ConfigArgs) (*ConfigReply, error)
	DeleteConfig(context.Context, *ConfigArgs) (*ConfigReply, error)
	ReplaceConfig(context.Context, *ConfigArgs) (*ConfigReply, error)
	CliConfig(context.Context, *CliConfigArgs) (*CliConfigReply, error)
	CommitReplace(context.Context, *CommitReplaceArgs) (*CommitReplaceReply, error)
	// Do we need implicit or explicit commit
	//
	CommitConfig(context.Context, *CommitArgs) (*CommitReply, error)
	ConfigDiscardChanges(context.Context, *DiscardChangesArgs) (*DiscardChangesReply, error)
	// Get only returns oper data
	//
	GetOper(*GetOperArgs, GRPCConfigOper_GetOperServer) error
	// Get Telemetry Data
	CreateSubs(*CreateSubsArgs, GRPCConfigOper_CreateSubsServer) error
}

func RegisterGRPCConfigOperServer(s *grpc.Server, srv GRPCConfigOperServer) {
	s.RegisterService(&_GRPCConfigOper_serviceDesc, srv)
}

func _GRPCConfigOper_GetConfig_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ConfigGetArgs)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GRPCConfigOperServer).GetConfig(m, &gRPCConfigOperGetConfigServer{stream})
}

type GRPCConfigOper_GetConfigServer interface {
	Send(*ConfigGetReply) error
	grpc.ServerStream
}

type gRPCConfigOperGetConfigServer struct {
	grpc.ServerStream
}

func (x *gRPCConfigOperGetConfigServer) Send(m *ConfigGetReply) error {
	return x.ServerStream.SendMsg(m)
}

func _GRPCConfigOper_MergeConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConfigArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GRPCConfigOperServer).MergeConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/IOSXRExtensibleManagabilityService.gRPCConfigOper/MergeConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GRPCConfigOperServer).MergeConfig(ctx, req.(*ConfigArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _GRPCConfigOper_DeleteConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConfigArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GRPCConfigOperServer).DeleteConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/IOSXRExtensibleManagabilityService.gRPCConfigOper/DeleteConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GRPCConfigOperServer).DeleteConfig(ctx, req.(*ConfigArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _GRPCConfigOper_ReplaceConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConfigArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GRPCConfigOperServer).ReplaceConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/IOSXRExtensibleManagabilityService.gRPCConfigOper/ReplaceConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GRPCConfigOperServer).ReplaceConfig(ctx, req.(*ConfigArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _GRPCConfigOper_CliConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CliConfigArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GRPCConfigOperServer).CliConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/IOSXRExtensibleManagabilityService.gRPCConfigOper/CliConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GRPCConfigOperServer).CliConfig(ctx, req.(*CliConfigArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _GRPCConfigOper_CommitReplace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CommitReplaceArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GRPCConfigOperServer).CommitReplace(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/IOSXRExtensibleManagabilityService.gRPCConfigOper/CommitReplace",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GRPCConfigOperServer).CommitReplace(ctx, req.(*CommitReplaceArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _GRPCConfigOper_CommitConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CommitArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GRPCConfigOperServer).CommitConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/IOSXRExtensibleManagabilityService.gRPCConfigOper/CommitConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GRPCConfigOperServer).CommitConfig(ctx, req.(*CommitArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _GRPCConfigOper_ConfigDiscardChanges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DiscardChangesArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GRPCConfigOperServer).ConfigDiscardChanges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/IOSXRExtensibleManagabilityService.gRPCConfigOper/ConfigDiscardChanges",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GRPCConfigOperServer).ConfigDiscardChanges(ctx, req.(*DiscardChangesArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _GRPCConfigOper_GetOper_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetOperArgs)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GRPCConfigOperServer).GetOper(m, &gRPCConfigOperGetOperServer{stream})
}

type GRPCConfigOper_GetOperServer interface {
	Send(*GetOperReply) error
	grpc.ServerStream
}

type gRPCConfigOperGetOperServer struct {
	grpc.ServerStream
}

func (x *gRPCConfigOperGetOperServer) Send(m *GetOperReply) error {
	return x.ServerStream.SendMsg(m)
}

func _GRPCConfigOper_CreateSubs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CreateSubsArgs)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GRPCConfigOperServer).CreateSubs(m, &gRPCConfigOperCreateSubsServer{stream})
}

type GRPCConfigOper_CreateSubsServer interface {
	Send(*CreateSubsReply) error
	grpc.ServerStream
}

type gRPCConfigOperCreateSubsServer struct {
	grpc.ServerStream
}

func (x *gRPCConfigOperCreateSubsServer) Send(m *CreateSubsReply) error {
	return x.ServerStream.SendMsg(m)
}

var _GRPCConfigOper_serviceDesc = grpc.ServiceDesc{
	ServiceName: "IOSXRExtensibleManagabilityService.gRPCConfigOper",
	HandlerType: (*GRPCConfigOperServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "MergeConfig",
			Handler:    _GRPCConfigOper_MergeConfig_Handler,
		},
		{
			MethodName: "DeleteConfig",
			Handler:    _GRPCConfigOper_DeleteConfig_Handler,
		},
		{
			MethodName: "ReplaceConfig",
			Handler:    _GRPCConfigOper_ReplaceConfig_Handler,
		},
		{
			MethodName: "CliConfig",
			Handler:    _GRPCConfigOper_CliConfig_Handler,
		},
		{
			MethodName: "CommitReplace",
			Handler:    _GRPCConfigOper_CommitReplace_Handler,
		},
		{
			MethodName: "CommitConfig",
			Handler:    _GRPCConfigOper_CommitConfig_Handler,
		},
		{
			MethodName: "ConfigDiscardChanges",
			Handler:    _GRPCConfigOper_ConfigDiscardChanges_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetConfig",
			Handler:       _GRPCConfigOper_GetConfig_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetOper",
			Handler:       _GRPCConfigOper_GetOper_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CreateSubs",
			Handler:       _GRPCConfigOper_CreateSubs_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "ems_grpc.proto",
}

// Client API for GRPCExec service

type GRPCExecClient interface {
	// Exec commands
	ShowCmdTextOutput(ctx context.Context, in *ShowCmdArgs, opts ...grpc.CallOption) (GRPCExec_ShowCmdTextOutputClient, error)
	ShowCmdJSONOutput(ctx context.Context, in *ShowCmdArgs, opts ...grpc.CallOption) (GRPCExec_ShowCmdJSONOutputClient, error)
	// rpc ActionCLI(ActionCliArgs) returns(stream ActionCliReply) {};
	ActionJSON(ctx context.Context, in *ActionJSONArgs, opts ...grpc.CallOption) (GRPCExec_ActionJSONClient, error)
}

type gRPCExecClient struct {
	cc *grpc.ClientConn
}

func NewGRPCExecClient(cc *grpc.ClientConn) GRPCExecClient {
	return &gRPCExecClient{cc}
}

func (c *gRPCExecClient) ShowCmdTextOutput(ctx context.Context, in *ShowCmdArgs, opts ...grpc.CallOption) (GRPCExec_ShowCmdTextOutputClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_GRPCExec_serviceDesc.Streams[0], c.cc, "/IOSXRExtensibleManagabilityService.gRPCExec/ShowCmdTextOutput", opts...)
	if err != nil {
		return nil, err
	}
	x := &gRPCExecShowCmdTextOutputClient{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 GRPCExec_ShowCmdTextOutputClient interface {
	Recv() (*ShowCmdTextReply, error)
	grpc.ClientStream
}

type gRPCExecShowCmdTextOutputClient struct {
	grpc.ClientStream
}

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

func (c *gRPCExecClient) ShowCmdJSONOutput(ctx context.Context, in *ShowCmdArgs, opts ...grpc.CallOption) (GRPCExec_ShowCmdJSONOutputClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_GRPCExec_serviceDesc.Streams[1], c.cc, "/IOSXRExtensibleManagabilityService.gRPCExec/ShowCmdJSONOutput", opts...)
	if err != nil {
		return nil, err
	}
	x := &gRPCExecShowCmdJSONOutputClient{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 GRPCExec_ShowCmdJSONOutputClient interface {
	Recv() (*ShowCmdJSONReply, error)
	grpc.ClientStream
}

type gRPCExecShowCmdJSONOutputClient struct {
	grpc.ClientStream
}

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

func (c *gRPCExecClient) ActionJSON(ctx context.Context, in *ActionJSONArgs, opts ...grpc.CallOption) (GRPCExec_ActionJSONClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_GRPCExec_serviceDesc.Streams[2], c.cc, "/IOSXRExtensibleManagabilityService.gRPCExec/ActionJSON", opts...)
	if err != nil {
		return nil, err
	}
	x := &gRPCExecActionJSONClient{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 GRPCExec_ActionJSONClient interface {
	Recv() (*ActionJSONReply, error)
	grpc.ClientStream
}

type gRPCExecActionJSONClient struct {
	grpc.ClientStream
}

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

// Server API for GRPCExec service

type GRPCExecServer interface {
	// Exec commands
	ShowCmdTextOutput(*ShowCmdArgs, GRPCExec_ShowCmdTextOutputServer) error
	ShowCmdJSONOutput(*ShowCmdArgs, GRPCExec_ShowCmdJSONOutputServer) error
	// rpc ActionCLI(ActionCliArgs) returns(stream ActionCliReply) {};
	ActionJSON(*ActionJSONArgs, GRPCExec_ActionJSONServer) error
}

func RegisterGRPCExecServer(s *grpc.Server, srv GRPCExecServer) {
	s.RegisterService(&_GRPCExec_serviceDesc, srv)
}

func _GRPCExec_ShowCmdTextOutput_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ShowCmdArgs)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GRPCExecServer).ShowCmdTextOutput(m, &gRPCExecShowCmdTextOutputServer{stream})
}

type GRPCExec_ShowCmdTextOutputServer interface {
	Send(*ShowCmdTextReply) error
	grpc.ServerStream
}

type gRPCExecShowCmdTextOutputServer struct {
	grpc.ServerStream
}

func (x *gRPCExecShowCmdTextOutputServer) Send(m *ShowCmdTextReply) error {
	return x.ServerStream.SendMsg(m)
}

func _GRPCExec_ShowCmdJSONOutput_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ShowCmdArgs)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GRPCExecServer).ShowCmdJSONOutput(m, &gRPCExecShowCmdJSONOutputServer{stream})
}

type GRPCExec_ShowCmdJSONOutputServer interface {
	Send(*ShowCmdJSONReply) error
	grpc.ServerStream
}

type gRPCExecShowCmdJSONOutputServer struct {
	grpc.ServerStream
}

func (x *gRPCExecShowCmdJSONOutputServer) Send(m *ShowCmdJSONReply) error {
	return x.ServerStream.SendMsg(m)
}

func _GRPCExec_ActionJSON_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ActionJSONArgs)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GRPCExecServer).ActionJSON(m, &gRPCExecActionJSONServer{stream})
}

type GRPCExec_ActionJSONServer interface {
	Send(*ActionJSONReply) error
	grpc.ServerStream
}

type gRPCExecActionJSONServer struct {
	grpc.ServerStream
}

func (x *gRPCExecActionJSONServer) Send(m *ActionJSONReply) error {
	return x.ServerStream.SendMsg(m)
}

var _GRPCExec_serviceDesc = grpc.ServiceDesc{
	ServiceName: "IOSXRExtensibleManagabilityService.gRPCExec",
	HandlerType: (*GRPCExecServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ShowCmdTextOutput",
			Handler:       _GRPCExec_ShowCmdTextOutput_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ShowCmdJSONOutput",
			Handler:       _GRPCExec_ShowCmdJSONOutput_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ActionJSON",
			Handler:       _GRPCExec_ActionJSON_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "ems_grpc.proto",
}

func init() { proto.RegisterFile("ems_grpc.proto", fileDescriptor0) }

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