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

package proto

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "github.com/golang/protobuf/ptypes/timestamp"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

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

// Item ...
type Item struct {
	// Types that are valid to be assigned to Item:
	//	*Item_Article
	Item                 isItem_Item `protobuf_oneof:"item"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

func (m *Item) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Item.Unmarshal(m, b)
}
func (m *Item) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Item.Marshal(b, m, deterministic)
}
func (m *Item) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Item.Merge(m, src)
}
func (m *Item) XXX_Size() int {
	return xxx_messageInfo_Item.Size(m)
}
func (m *Item) XXX_DiscardUnknown() {
	xxx_messageInfo_Item.DiscardUnknown(m)
}

var xxx_messageInfo_Item proto.InternalMessageInfo

type isItem_Item interface {
	isItem_Item()
}

type Item_Article struct {
	Article *Article `protobuf:"bytes,10,opt,name=article,proto3,oneof"`
}

func (*Item_Article) isItem_Item() {}

func (m *Item) GetItem() isItem_Item {
	if m != nil {
		return m.Item
	}
	return nil
}

func (m *Item) GetArticle() *Article {
	if x, ok := m.GetItem().(*Item_Article); ok {
		return x.Article
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Item) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Item_Article)(nil),
	}
}

// Article ...
type Article struct {
	// UUID ...
	Uuid string `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	// Title ...
	Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	// Body ...
	Body                 string   `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Article) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Article.Unmarshal(m, b)
}
func (m *Article) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Article.Marshal(b, m, deterministic)
}
func (m *Article) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Article.Merge(m, src)
}
func (m *Article) XXX_Size() int {
	return xxx_messageInfo_Article.Size(m)
}
func (m *Article) XXX_DiscardUnknown() {
	xxx_messageInfo_Article.DiscardUnknown(m)
}

var xxx_messageInfo_Article proto.InternalMessageInfo

func (m *Article) GetUuid() string {
	if m != nil {
		return m.Uuid
	}
	return ""
}

func (m *Article) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *Article) GetBody() string {
	if m != nil {
		return m.Body
	}
	return ""
}

// Insert ...
type Insert struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Insert) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Insert.Unmarshal(m, b)
}
func (m *Insert) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Insert.Marshal(b, m, deterministic)
}
func (m *Insert) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Insert.Merge(m, src)
}
func (m *Insert) XXX_Size() int {
	return xxx_messageInfo_Insert.Size(m)
}
func (m *Insert) XXX_DiscardUnknown() {
	xxx_messageInfo_Insert.DiscardUnknown(m)
}

var xxx_messageInfo_Insert proto.InternalMessageInfo

// Request ...
type Insert_Request struct {
	Item                 *Item    `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Insert_Request) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Insert_Request.Unmarshal(m, b)
}
func (m *Insert_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Insert_Request.Marshal(b, m, deterministic)
}
func (m *Insert_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Insert_Request.Merge(m, src)
}
func (m *Insert_Request) XXX_Size() int {
	return xxx_messageInfo_Insert_Request.Size(m)
}
func (m *Insert_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_Insert_Request.DiscardUnknown(m)
}

var xxx_messageInfo_Insert_Request proto.InternalMessageInfo

func (m *Insert_Request) GetItem() *Item {
	if m != nil {
		return m.Item
	}
	return nil
}

// Response ...
type Insert_Response struct {
	Uuid                 string   `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Insert_Response) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Insert_Response.Unmarshal(m, b)
}
func (m *Insert_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Insert_Response.Marshal(b, m, deterministic)
}
func (m *Insert_Response) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Insert_Response.Merge(m, src)
}
func (m *Insert_Response) XXX_Size() int {
	return xxx_messageInfo_Insert_Response.Size(m)
}
func (m *Insert_Response) XXX_DiscardUnknown() {
	xxx_messageInfo_Insert_Response.DiscardUnknown(m)
}

var xxx_messageInfo_Insert_Response proto.InternalMessageInfo

func (m *Insert_Response) GetUuid() string {
	if m != nil {
		return m.Uuid
	}
	return ""
}

// Update ...
type Update struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Update) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Update.Unmarshal(m, b)
}
func (m *Update) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Update.Marshal(b, m, deterministic)
}
func (m *Update) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Update.Merge(m, src)
}
func (m *Update) XXX_Size() int {
	return xxx_messageInfo_Update.Size(m)
}
func (m *Update) XXX_DiscardUnknown() {
	xxx_messageInfo_Update.DiscardUnknown(m)
}

var xxx_messageInfo_Update proto.InternalMessageInfo

// Request ...
type Update_Request struct {
	Item                 *Item    `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Update_Request) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Update_Request.Unmarshal(m, b)
}
func (m *Update_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Update_Request.Marshal(b, m, deterministic)
}
func (m *Update_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Update_Request.Merge(m, src)
}
func (m *Update_Request) XXX_Size() int {
	return xxx_messageInfo_Update_Request.Size(m)
}
func (m *Update_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_Update_Request.DiscardUnknown(m)
}

var xxx_messageInfo_Update_Request proto.InternalMessageInfo

func (m *Update_Request) GetItem() *Item {
	if m != nil {
		return m.Item
	}
	return nil
}

// Response ...
type Update_Response struct {
	Uuid                 string   `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Update_Response) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Update_Response.Unmarshal(m, b)
}
func (m *Update_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Update_Response.Marshal(b, m, deterministic)
}
func (m *Update_Response) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Update_Response.Merge(m, src)
}
func (m *Update_Response) XXX_Size() int {
	return xxx_messageInfo_Update_Response.Size(m)
}
func (m *Update_Response) XXX_DiscardUnknown() {
	xxx_messageInfo_Update_Response.DiscardUnknown(m)
}

var xxx_messageInfo_Update_Response proto.InternalMessageInfo

func (m *Update_Response) GetUuid() string {
	if m != nil {
		return m.Uuid
	}
	return ""
}

// ListArticles ...
type ListArticles struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *ListArticles) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListArticles.Unmarshal(m, b)
}
func (m *ListArticles) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListArticles.Marshal(b, m, deterministic)
}
func (m *ListArticles) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListArticles.Merge(m, src)
}
func (m *ListArticles) XXX_Size() int {
	return xxx_messageInfo_ListArticles.Size(m)
}
func (m *ListArticles) XXX_DiscardUnknown() {
	xxx_messageInfo_ListArticles.DiscardUnknown(m)
}

var xxx_messageInfo_ListArticles proto.InternalMessageInfo

// Request ...
type ListArticles_Request struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *ListArticles_Request) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListArticles_Request.Unmarshal(m, b)
}
func (m *ListArticles_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListArticles_Request.Marshal(b, m, deterministic)
}
func (m *ListArticles_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListArticles_Request.Merge(m, src)
}
func (m *ListArticles_Request) XXX_Size() int {
	return xxx_messageInfo_ListArticles_Request.Size(m)
}
func (m *ListArticles_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_ListArticles_Request.DiscardUnknown(m)
}

var xxx_messageInfo_ListArticles_Request proto.InternalMessageInfo

// Response ...
type ListArticles_Response struct {
	Articles             []*Article `protobuf:"bytes,1,rep,name=articles,proto3" json:"articles,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

func (m *ListArticles_Response) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListArticles_Response.Unmarshal(m, b)
}
func (m *ListArticles_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListArticles_Response.Marshal(b, m, deterministic)
}
func (m *ListArticles_Response) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListArticles_Response.Merge(m, src)
}
func (m *ListArticles_Response) XXX_Size() int {
	return xxx_messageInfo_ListArticles_Response.Size(m)
}
func (m *ListArticles_Response) XXX_DiscardUnknown() {
	xxx_messageInfo_ListArticles_Response.DiscardUnknown(m)
}

var xxx_messageInfo_ListArticles_Response proto.InternalMessageInfo

func (m *ListArticles_Response) GetArticles() []*Article {
	if m != nil {
		return m.Articles
	}
	return nil
}

// Empty ...
type Empty struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Empty) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Empty.Unmarshal(m, b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
}
func (m *Empty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Empty.Merge(m, src)
}
func (m *Empty) XXX_Size() int {
	return xxx_messageInfo_Empty.Size(m)
}
func (m *Empty) XXX_DiscardUnknown() {
	xxx_messageInfo_Empty.DiscardUnknown(m)
}

var xxx_messageInfo_Empty proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Item)(nil), "proto.Item")
	proto.RegisterType((*Article)(nil), "proto.Article")
	proto.RegisterType((*Insert)(nil), "proto.Insert")
	proto.RegisterType((*Insert_Request)(nil), "proto.Insert.Request")
	proto.RegisterType((*Insert_Response)(nil), "proto.Insert.Response")
	proto.RegisterType((*Update)(nil), "proto.Update")
	proto.RegisterType((*Update_Request)(nil), "proto.Update.Request")
	proto.RegisterType((*Update_Response)(nil), "proto.Update.Response")
	proto.RegisterType((*ListArticles)(nil), "proto.ListArticles")
	proto.RegisterType((*ListArticles_Request)(nil), "proto.ListArticles.Request")
	proto.RegisterType((*ListArticles_Response)(nil), "proto.ListArticles.Response")
	proto.RegisterType((*Empty)(nil), "proto.Empty")
}

func init() {
	proto.RegisterFile("proto.proto", fileDescriptor_2fcc84b9998d60d8)
}

var fileDescriptor_2fcc84b9998d60d8 = []byte{
	// 318 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x50, 0xc1, 0x4a, 0xc3, 0x40,
	0x10, 0x75, 0x6d, 0xd3, 0xb4, 0x13, 0xf1, 0xb0, 0xa8, 0x84, 0x28, 0xb6, 0xe4, 0x54, 0x7a, 0x68,
	0x25, 0x82, 0x05, 0x6f, 0x0a, 0xa2, 0x45, 0x3d, 0xb8, 0xe8, 0x07, 0x24, 0xcd, 0x5a, 0x16, 0x92,
	0x6e, 0xcc, 0x4e, 0x0e, 0xfd, 0x41, 0xbf, 0x4b, 0xb2, 0xbb, 0x09, 0xd5, 0xf6, 0xe8, 0x25, 0xd9,
	0x79, 0xef, 0xcd, 0x7b, 0x33, 0x03, 0x5e, 0x51, 0x4a, 0x94, 0x53, 0xfd, 0xa5, 0x8e, 0xfe, 0x05,
	0xc3, 0x95, 0x94, 0xab, 0x8c, 0xcf, 0x74, 0x95, 0x54, 0x9f, 0x33, 0x14, 0x39, 0x57, 0x18, 0xe7,
	0x85, 0xd1, 0x85, 0xb7, 0xd0, 0x5d, 0x20, 0xcf, 0xe9, 0x04, 0xdc, 0xb8, 0x44, 0xb1, 0xcc, 0xb8,
	0x0f, 0x23, 0x32, 0xf6, 0xa2, 0x63, 0x23, 0x98, 0xde, 0x19, 0xf4, 0xe9, 0x80, 0x35, 0x82, 0xfb,
	0x1e, 0x74, 0x05, 0xf2, 0x3c, 0x7c, 0x04, 0xd7, 0xb2, 0x94, 0x42, 0xb7, 0xaa, 0x44, 0xea, 0x93,
	0x11, 0x19, 0x0f, 0x98, 0x7e, 0xd3, 0x13, 0x70, 0x50, 0x60, 0xc6, 0xfd, 0x43, 0x0d, 0x9a, 0xa2,
	0x56, 0x26, 0x32, 0xdd, 0xf8, 0x1d, 0xa3, 0xac, 0xdf, 0xe1, 0x3b, 0xf4, 0x16, 0x6b, 0xc5, 0x4b,
	0x0c, 0x26, 0xe0, 0x32, 0xfe, 0x55, 0x71, 0x85, 0x74, 0x68, 0x52, 0xb4, 0xa5, 0x17, 0x79, 0x76,
	0x9c, 0x7a, 0x58, 0xa6, 0x89, 0xe0, 0x12, 0xfa, 0x8c, 0xab, 0x42, 0xae, 0xd5, 0xde, 0xfc, 0xda,
	0xf5, 0xa3, 0x48, 0x63, 0xe4, 0xff, 0xea, 0xfa, 0x06, 0x47, 0x2f, 0x42, 0xa1, 0x5d, 0x5c, 0x05,
	0x83, 0xd6, 0x3b, 0xb8, 0xd9, 0x6a, 0x9d, 0x40, 0xdf, 0x9e, 0x4b, 0xf9, 0x64, 0xd4, 0xd9, 0x3d,
	0x28, 0x6b, 0xf9, 0xd0, 0x05, 0xe7, 0x21, 0x2f, 0x70, 0x13, 0x7d, 0x13, 0x70, 0x5e, 0xc5, 0xb2,
	0x94, 0x74, 0xde, 0x5c, 0x84, 0x9e, 0x36, 0x23, 0xea, 0x72, 0xda, 0x64, 0x9d, 0xfd, 0x85, 0x6d,
	0xee, 0xbc, 0x59, 0xba, 0x6d, 0x34, 0xe5, 0x4e, 0x63, 0x0b, 0xdb, 0xc6, 0xe7, 0xdf, 0x7b, 0xd1,
	0x73, 0xab, 0xdb, 0x06, 0x5b, 0x93, 0x8b, 0xfd, 0xa4, 0xb1, 0xba, 0x22, 0x49, 0x4f, 0xd3, 0xd7,
	0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x6a, 0x70, 0xf3, 0x93, 0x02, 0x00, 0x00,
}

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

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

// MicroClient is the client API for Micro service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MicroClient interface {
	// Insert ...
	Insert(ctx context.Context, in *Insert_Request, opts ...grpc.CallOption) (*Insert_Response, error)
	// Update ...
	Update(ctx context.Context, in *Update_Request, opts ...grpc.CallOption) (*Update_Response, error)
	// ListArticles ...
	ListArticles(ctx context.Context, in *ListArticles_Request, opts ...grpc.CallOption) (Micro_ListArticlesClient, error)
}

type microClient struct {
	cc grpc.ClientConnInterface
}

func NewMicroClient(cc grpc.ClientConnInterface) MicroClient {
	return &microClient{cc}
}

func (c *microClient) Insert(ctx context.Context, in *Insert_Request, opts ...grpc.CallOption) (*Insert_Response, error) {
	out := new(Insert_Response)
	err := c.cc.Invoke(ctx, "/proto.Micro/Insert", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *microClient) Update(ctx context.Context, in *Update_Request, opts ...grpc.CallOption) (*Update_Response, error) {
	out := new(Update_Response)
	err := c.cc.Invoke(ctx, "/proto.Micro/Update", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *microClient) ListArticles(ctx context.Context, in *ListArticles_Request, opts ...grpc.CallOption) (Micro_ListArticlesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Micro_serviceDesc.Streams[0], "/proto.Micro/ListArticles", opts...)
	if err != nil {
		return nil, err
	}
	x := &microListArticlesClient{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 Micro_ListArticlesClient interface {
	Recv() (*ListArticles_Response, error)
	grpc.ClientStream
}

type microListArticlesClient struct {
	grpc.ClientStream
}

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

// MicroServer is the server API for Micro service.
type MicroServer interface {
	// Insert ...
	Insert(context.Context, *Insert_Request) (*Insert_Response, error)
	// Update ...
	Update(context.Context, *Update_Request) (*Update_Response, error)
	// ListArticles ...
	ListArticles(*ListArticles_Request, Micro_ListArticlesServer) error
}

// UnimplementedMicroServer can be embedded to have forward compatible implementations.
type UnimplementedMicroServer struct {
}

func (*UnimplementedMicroServer) Insert(ctx context.Context, req *Insert_Request) (*Insert_Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Insert not implemented")
}
func (*UnimplementedMicroServer) Update(ctx context.Context, req *Update_Request) (*Update_Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
}
func (*UnimplementedMicroServer) ListArticles(req *ListArticles_Request, srv Micro_ListArticlesServer) error {
	return status.Errorf(codes.Unimplemented, "method ListArticles not implemented")
}

func RegisterMicroServer(s *grpc.Server, srv MicroServer) {
	s.RegisterService(&_Micro_serviceDesc, srv)
}

func _Micro_Insert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Insert_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MicroServer).Insert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Micro/Insert",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MicroServer).Insert(ctx, req.(*Insert_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _Micro_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Update_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MicroServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Micro/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MicroServer).Update(ctx, req.(*Update_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _Micro_ListArticles_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListArticles_Request)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(MicroServer).ListArticles(m, &microListArticlesServer{stream})
}

type Micro_ListArticlesServer interface {
	Send(*ListArticles_Response) error
	grpc.ServerStream
}

type microListArticlesServer struct {
	grpc.ServerStream
}

func (x *microListArticlesServer) Send(m *ListArticles_Response) error {
	return x.ServerStream.SendMsg(m)
}

var _Micro_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.Micro",
	HandlerType: (*MicroServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Insert",
			Handler:    _Micro_Insert_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _Micro_Update_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListArticles",
			Handler:       _Micro_ListArticles_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "proto.proto",
}