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

package filesystem

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	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

type DomainReq struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	MetaFields           []string `protobuf:"bytes,2,rep,name=metaFields,proto3" json:"metaFields,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DomainReq proto.InternalMessageInfo

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

func (m *DomainReq) GetMetaFields() []string {
	if m != nil {
		return m.MetaFields
	}
	return nil
}

type DomainResp struct {
	State                bool     `protobuf:"varint,1,opt,name=state,proto3" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DomainResp proto.InternalMessageInfo

func (m *DomainResp) GetState() bool {
	if m != nil {
		return m.State
	}
	return false
}

//
type SaveFileReq struct {
	Domain               string            `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty"`
	Meta                 map[string]string `protobuf:"bytes,2,rep,name=meta,proto3" json:"meta,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	RawFileContent       []byte            `protobuf:"bytes,3,opt,name=rawFileContent,proto3" json:"rawFileContent,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_SaveFileReq proto.InternalMessageInfo

func (m *SaveFileReq) GetDomain() string {
	if m != nil {
		return m.Domain
	}
	return ""
}

func (m *SaveFileReq) GetMeta() map[string]string {
	if m != nil {
		return m.Meta
	}
	return nil
}

func (m *SaveFileReq) GetRawFileContent() []byte {
	if m != nil {
		return m.RawFileContent
	}
	return nil
}

//
type FileOpResp struct {
	State                bool     `protobuf:"varint,1,opt,name=state,proto3" json:"state,omitempty"`
	Domain               string   `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"`
	FileId               string   `protobuf:"bytes,3,opt,name=fileId,proto3" json:"fileId,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_FileOpResp proto.InternalMessageInfo

func (m *FileOpResp) GetState() bool {
	if m != nil {
		return m.State
	}
	return false
}

func (m *FileOpResp) GetDomain() string {
	if m != nil {
		return m.Domain
	}
	return ""
}

func (m *FileOpResp) GetFileId() string {
	if m != nil {
		return m.FileId
	}
	return ""
}

//
type UpdateFileMetaReq struct {
	Domain               string            `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty"`
	FileId               string            `protobuf:"bytes,2,opt,name=fileId,proto3" json:"fileId,omitempty"`
	Meta                 map[string]string `protobuf:"bytes,3,rep,name=meta,proto3" json:"meta,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_UpdateFileMetaReq proto.InternalMessageInfo

func (m *UpdateFileMetaReq) GetDomain() string {
	if m != nil {
		return m.Domain
	}
	return ""
}

func (m *UpdateFileMetaReq) GetFileId() string {
	if m != nil {
		return m.FileId
	}
	return ""
}

func (m *UpdateFileMetaReq) GetMeta() map[string]string {
	if m != nil {
		return m.Meta
	}
	return nil
}

//
type LoadFileReq struct {
	Domain               string   `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty"`
	FileId               string   `protobuf:"bytes,2,opt,name=fileId,proto3" json:"fileId,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_LoadFileReq proto.InternalMessageInfo

func (m *LoadFileReq) GetDomain() string {
	if m != nil {
		return m.Domain
	}
	return ""
}

func (m *LoadFileReq) GetFileId() string {
	if m != nil {
		return m.FileId
	}
	return ""
}

//
type LoadFileResp struct {
	Meta                 map[string]string `protobuf:"bytes,2,rep,name=meta,proto3" json:"meta,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	RawFileContent       []byte            `protobuf:"bytes,3,opt,name=rawFileContent,proto3" json:"rawFileContent,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_LoadFileResp proto.InternalMessageInfo

func (m *LoadFileResp) GetMeta() map[string]string {
	if m != nil {
		return m.Meta
	}
	return nil
}

func (m *LoadFileResp) GetRawFileContent() []byte {
	if m != nil {
		return m.RawFileContent
	}
	return nil
}

//
type LoadFileMetaResp struct {
	Meta                 map[string]string `protobuf:"bytes,2,rep,name=meta,proto3" json:"meta,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_LoadFileMetaResp proto.InternalMessageInfo

func (m *LoadFileMetaResp) GetMeta() map[string]string {
	if m != nil {
		return m.Meta
	}
	return nil
}

func init() {
	proto.RegisterType((*DomainReq)(nil), "filesystem.DomainReq")
	proto.RegisterType((*DomainResp)(nil), "filesystem.DomainResp")
	proto.RegisterType((*SaveFileReq)(nil), "filesystem.SaveFileReq")
	proto.RegisterMapType((map[string]string)(nil), "filesystem.SaveFileReq.MetaEntry")
	proto.RegisterType((*FileOpResp)(nil), "filesystem.FileOpResp")
	proto.RegisterType((*UpdateFileMetaReq)(nil), "filesystem.UpdateFileMetaReq")
	proto.RegisterMapType((map[string]string)(nil), "filesystem.UpdateFileMetaReq.MetaEntry")
	proto.RegisterType((*LoadFileReq)(nil), "filesystem.LoadFileReq")
	proto.RegisterType((*LoadFileResp)(nil), "filesystem.LoadFileResp")
	proto.RegisterMapType((map[string]string)(nil), "filesystem.LoadFileResp.MetaEntry")
	proto.RegisterType((*LoadFileMetaResp)(nil), "filesystem.LoadFileMetaResp")
	proto.RegisterMapType((map[string]string)(nil), "filesystem.LoadFileMetaResp.MetaEntry")
}

func init() {
	proto.RegisterFile("filesystem.proto", fileDescriptor_0a9f8093c6c7067e)
}

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

// FileSystemClient is the client API for FileSystem service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type FileSystemClient interface {
	//创建域
	CreateDomain(ctx context.Context, in *DomainReq, opts ...grpc.CallOption) (*DomainResp, error)
	//更新域
	UpdateDomainMeta(ctx context.Context, in *DomainReq, opts ...grpc.CallOption) (*DomainResp, error)
	//删除域
	DeleteDomain(ctx context.Context, in *DomainReq, opts ...grpc.CallOption) (*DomainResp, error)
	//保存文件
	SaveFile(ctx context.Context, in *SaveFileReq, opts ...grpc.CallOption) (*FileOpResp, error)
	//更新文件元数据
	UpdateFileMeta(ctx context.Context, in *UpdateFileMetaReq, opts ...grpc.CallOption) (*FileOpResp, error)
	//删除文件
	DeleteFile(ctx context.Context, in *LoadFileReq, opts ...grpc.CallOption) (*FileOpResp, error)
	//获取文件
	GetFile(ctx context.Context, in *LoadFileReq, opts ...grpc.CallOption) (*LoadFileResp, error)
	//获取文件元数据
	GetFileMeta(ctx context.Context, in *LoadFileReq, opts ...grpc.CallOption) (*LoadFileMetaResp, error)
}

type fileSystemClient struct {
	cc grpc.ClientConnInterface
}

func NewFileSystemClient(cc grpc.ClientConnInterface) FileSystemClient {
	return &fileSystemClient{cc}
}

func (c *fileSystemClient) CreateDomain(ctx context.Context, in *DomainReq, opts ...grpc.CallOption) (*DomainResp, error) {
	out := new(DomainResp)
	err := c.cc.Invoke(ctx, "/filesystem.FileSystem/CreateDomain", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fileSystemClient) UpdateDomainMeta(ctx context.Context, in *DomainReq, opts ...grpc.CallOption) (*DomainResp, error) {
	out := new(DomainResp)
	err := c.cc.Invoke(ctx, "/filesystem.FileSystem/UpdateDomainMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fileSystemClient) DeleteDomain(ctx context.Context, in *DomainReq, opts ...grpc.CallOption) (*DomainResp, error) {
	out := new(DomainResp)
	err := c.cc.Invoke(ctx, "/filesystem.FileSystem/DeleteDomain", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fileSystemClient) SaveFile(ctx context.Context, in *SaveFileReq, opts ...grpc.CallOption) (*FileOpResp, error) {
	out := new(FileOpResp)
	err := c.cc.Invoke(ctx, "/filesystem.FileSystem/SaveFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fileSystemClient) UpdateFileMeta(ctx context.Context, in *UpdateFileMetaReq, opts ...grpc.CallOption) (*FileOpResp, error) {
	out := new(FileOpResp)
	err := c.cc.Invoke(ctx, "/filesystem.FileSystem/UpdateFileMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fileSystemClient) DeleteFile(ctx context.Context, in *LoadFileReq, opts ...grpc.CallOption) (*FileOpResp, error) {
	out := new(FileOpResp)
	err := c.cc.Invoke(ctx, "/filesystem.FileSystem/DeleteFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fileSystemClient) GetFile(ctx context.Context, in *LoadFileReq, opts ...grpc.CallOption) (*LoadFileResp, error) {
	out := new(LoadFileResp)
	err := c.cc.Invoke(ctx, "/filesystem.FileSystem/GetFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fileSystemClient) GetFileMeta(ctx context.Context, in *LoadFileReq, opts ...grpc.CallOption) (*LoadFileMetaResp, error) {
	out := new(LoadFileMetaResp)
	err := c.cc.Invoke(ctx, "/filesystem.FileSystem/GetFileMeta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// FileSystemServer is the server API for FileSystem service.
type FileSystemServer interface {
	//创建域
	CreateDomain(context.Context, *DomainReq) (*DomainResp, error)
	//更新域
	UpdateDomainMeta(context.Context, *DomainReq) (*DomainResp, error)
	//删除域
	DeleteDomain(context.Context, *DomainReq) (*DomainResp, error)
	//保存文件
	SaveFile(context.Context, *SaveFileReq) (*FileOpResp, error)
	//更新文件元数据
	UpdateFileMeta(context.Context, *UpdateFileMetaReq) (*FileOpResp, error)
	//删除文件
	DeleteFile(context.Context, *LoadFileReq) (*FileOpResp, error)
	//获取文件
	GetFile(context.Context, *LoadFileReq) (*LoadFileResp, error)
	//获取文件元数据
	GetFileMeta(context.Context, *LoadFileReq) (*LoadFileMetaResp, error)
}

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

func (*UnimplementedFileSystemServer) CreateDomain(ctx context.Context, req *DomainReq) (*DomainResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateDomain not implemented")
}
func (*UnimplementedFileSystemServer) UpdateDomainMeta(ctx context.Context, req *DomainReq) (*DomainResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateDomainMeta not implemented")
}
func (*UnimplementedFileSystemServer) DeleteDomain(ctx context.Context, req *DomainReq) (*DomainResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteDomain not implemented")
}
func (*UnimplementedFileSystemServer) SaveFile(ctx context.Context, req *SaveFileReq) (*FileOpResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SaveFile not implemented")
}
func (*UnimplementedFileSystemServer) UpdateFileMeta(ctx context.Context, req *UpdateFileMetaReq) (*FileOpResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateFileMeta not implemented")
}
func (*UnimplementedFileSystemServer) DeleteFile(ctx context.Context, req *LoadFileReq) (*FileOpResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteFile not implemented")
}
func (*UnimplementedFileSystemServer) GetFile(ctx context.Context, req *LoadFileReq) (*LoadFileResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetFile not implemented")
}
func (*UnimplementedFileSystemServer) GetFileMeta(ctx context.Context, req *LoadFileReq) (*LoadFileMetaResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetFileMeta not implemented")
}

func RegisterFileSystemServer(s *grpc.Server, srv FileSystemServer) {
	s.RegisterService(&_FileSystem_serviceDesc, srv)
}

func _FileSystem_CreateDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DomainReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FileSystemServer).CreateDomain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/filesystem.FileSystem/CreateDomain",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FileSystemServer).CreateDomain(ctx, req.(*DomainReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FileSystem_UpdateDomainMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DomainReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FileSystemServer).UpdateDomainMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/filesystem.FileSystem/UpdateDomainMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FileSystemServer).UpdateDomainMeta(ctx, req.(*DomainReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FileSystem_DeleteDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DomainReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FileSystemServer).DeleteDomain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/filesystem.FileSystem/DeleteDomain",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FileSystemServer).DeleteDomain(ctx, req.(*DomainReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FileSystem_SaveFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SaveFileReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FileSystemServer).SaveFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/filesystem.FileSystem/SaveFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FileSystemServer).SaveFile(ctx, req.(*SaveFileReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FileSystem_UpdateFileMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateFileMetaReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FileSystemServer).UpdateFileMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/filesystem.FileSystem/UpdateFileMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FileSystemServer).UpdateFileMeta(ctx, req.(*UpdateFileMetaReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FileSystem_DeleteFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadFileReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FileSystemServer).DeleteFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/filesystem.FileSystem/DeleteFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FileSystemServer).DeleteFile(ctx, req.(*LoadFileReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FileSystem_GetFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadFileReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FileSystemServer).GetFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/filesystem.FileSystem/GetFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FileSystemServer).GetFile(ctx, req.(*LoadFileReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FileSystem_GetFileMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadFileReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FileSystemServer).GetFileMeta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/filesystem.FileSystem/GetFileMeta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FileSystemServer).GetFileMeta(ctx, req.(*LoadFileReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _FileSystem_serviceDesc = grpc.ServiceDesc{
	ServiceName: "filesystem.FileSystem",
	HandlerType: (*FileSystemServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateDomain",
			Handler:    _FileSystem_CreateDomain_Handler,
		},
		{
			MethodName: "UpdateDomainMeta",
			Handler:    _FileSystem_UpdateDomainMeta_Handler,
		},
		{
			MethodName: "DeleteDomain",
			Handler:    _FileSystem_DeleteDomain_Handler,
		},
		{
			MethodName: "SaveFile",
			Handler:    _FileSystem_SaveFile_Handler,
		},
		{
			MethodName: "UpdateFileMeta",
			Handler:    _FileSystem_UpdateFileMeta_Handler,
		},
		{
			MethodName: "DeleteFile",
			Handler:    _FileSystem_DeleteFile_Handler,
		},
		{
			MethodName: "GetFile",
			Handler:    _FileSystem_GetFile_Handler,
		},
		{
			MethodName: "GetFileMeta",
			Handler:    _FileSystem_GetFileMeta_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "filesystem.proto",
}