// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v3.19.0
// source: interservice/ingest/chef.proto

package ingest

import (
	context "context"
	request "github.com/chef/automate/api/external/ingest/request"
	response "github.com/chef/automate/api/external/ingest/response"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// Version message
//
// The ingest-service version constructed with:
// * Service name
// * Built time
// * Semantic version
// * Git SHA
type Version struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Version       string                 `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty" toml:"version,omitempty" mapstructure:"version,omitempty"`
	Built         string                 `protobuf:"bytes,1,opt,name=built,proto3" json:"built,omitempty" toml:"built,omitempty" mapstructure:"built,omitempty"`
	Name          string                 `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty" toml:"name,omitempty" mapstructure:"name,omitempty"`
	Sha           string                 `protobuf:"bytes,4,opt,name=sha,proto3" json:"sha,omitempty" toml:"sha,omitempty" mapstructure:"sha,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Version) Reset() {
	*x = Version{}
	mi := &file_interservice_ingest_chef_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Version) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Version) ProtoMessage() {}

func (x *Version) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_ingest_chef_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Version.ProtoReflect.Descriptor instead.
func (*Version) Descriptor() ([]byte, []int) {
	return file_interservice_ingest_chef_proto_rawDescGZIP(), []int{0}
}

func (x *Version) GetVersion() string {
	if x != nil {
		return x.Version
	}
	return ""
}

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

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

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

type VersionRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *VersionRequest) Reset() {
	*x = VersionRequest{}
	mi := &file_interservice_ingest_chef_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *VersionRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*VersionRequest) ProtoMessage() {}

func (x *VersionRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_ingest_chef_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use VersionRequest.ProtoReflect.Descriptor instead.
func (*VersionRequest) Descriptor() ([]byte, []int) {
	return file_interservice_ingest_chef_proto_rawDescGZIP(), []int{1}
}

type StartReindexRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *StartReindexRequest) Reset() {
	*x = StartReindexRequest{}
	mi := &file_interservice_ingest_chef_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StartReindexRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*StartReindexRequest) ProtoMessage() {}

func (x *StartReindexRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_ingest_chef_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use StartReindexRequest.ProtoReflect.Descriptor instead.
func (*StartReindexRequest) Descriptor() ([]byte, []int) {
	return file_interservice_ingest_chef_proto_rawDescGZIP(), []int{2}
}

type StartReindexResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Message       string                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty" toml:"message,omitempty" mapstructure:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *StartReindexResponse) Reset() {
	*x = StartReindexResponse{}
	mi := &file_interservice_ingest_chef_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StartReindexResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*StartReindexResponse) ProtoMessage() {}

func (x *StartReindexResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_ingest_chef_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use StartReindexResponse.ProtoReflect.Descriptor instead.
func (*StartReindexResponse) Descriptor() ([]byte, []int) {
	return file_interservice_ingest_chef_proto_rawDescGZIP(), []int{3}
}

func (x *StartReindexResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

type GetReindexStatusResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	StatusJson    string                 `protobuf:"bytes,1,opt,name=status_json,json=statusJson,proto3" json:"status_json,omitempty" toml:"status_json,omitempty" mapstructure:"status_json,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetReindexStatusResponse) Reset() {
	*x = GetReindexStatusResponse{}
	mi := &file_interservice_ingest_chef_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetReindexStatusResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetReindexStatusResponse) ProtoMessage() {}

func (x *GetReindexStatusResponse) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_ingest_chef_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetReindexStatusResponse.ProtoReflect.Descriptor instead.
func (*GetReindexStatusResponse) Descriptor() ([]byte, []int) {
	return file_interservice_ingest_chef_proto_rawDescGZIP(), []int{4}
}

func (x *GetReindexStatusResponse) GetStatusJson() string {
	if x != nil {
		return x.StatusJson
	}
	return ""
}

type GetReindexStatusRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	RequestId     int32                  `protobuf:"varint,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty" toml:"request_id,omitempty" mapstructure:"request_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetReindexStatusRequest) Reset() {
	*x = GetReindexStatusRequest{}
	mi := &file_interservice_ingest_chef_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetReindexStatusRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetReindexStatusRequest) ProtoMessage() {}

func (x *GetReindexStatusRequest) ProtoReflect() protoreflect.Message {
	mi := &file_interservice_ingest_chef_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetReindexStatusRequest.ProtoReflect.Descriptor instead.
func (*GetReindexStatusRequest) Descriptor() ([]byte, []int) {
	return file_interservice_ingest_chef_proto_rawDescGZIP(), []int{5}
}

func (x *GetReindexStatusRequest) GetRequestId() int32 {
	if x != nil {
		return x.RequestId
	}
	return 0
}

var File_interservice_ingest_chef_proto protoreflect.FileDescriptor

const file_interservice_ingest_chef_proto_rawDesc = "" +
	"\n" +
	"\x1einterservice/ingest/chef.proto\x12\x1bchef.automate.domain.ingest\x1a\x1cgoogle/api/annotations.proto\x1a\"external/ingest/request/chef.proto\x1a$external/ingest/request/action.proto\x1a&external/ingest/request/liveness.proto\x1a#external/ingest/response/chef.proto\x1a%external/ingest/response/action.proto\x1a'external/ingest/response/liveness.proto\"_\n" +
	"\aVersion\x12\x18\n" +
	"\aversion\x18\x02 \x01(\tR\aversion\x12\x14\n" +
	"\x05built\x18\x01 \x01(\tR\x05built\x12\x12\n" +
	"\x04name\x18\x03 \x01(\tR\x04name\x12\x10\n" +
	"\x03sha\x18\x04 \x01(\tR\x03sha\"\x10\n" +
	"\x0eVersionRequest\"\x15\n" +
	"\x13StartReindexRequest\"0\n" +
	"\x14StartReindexResponse\x12\x18\n" +
	"\amessage\x18\x01 \x01(\tR\amessage\";\n" +
	"\x18GetReindexStatusResponse\x12\x1f\n" +
	"\vstatus_json\x18\x01 \x01(\tR\n" +
	"statusJson\"8\n" +
	"\x17GetReindexStatusRequest\x12\x1d\n" +
	"\n" +
	"request_id\x18\x01 \x01(\x05R\trequestId2\x8d\n" +
	"\n" +
	"\x13ChefIngesterService\x12\x96\x01\n" +
	"\x0eProcessChefRun\x12%.chef.automate.api.ingest.request.Run\x1a9.chef.automate.api.ingest.response.ProcessChefRunResponse\"\"\x82\xd3\xe4\x93\x02\x1c:\x01*\"\x17/api/v0/events/chef/run\x12\xa2\x01\n" +
	"\x11ProcessChefAction\x12(.chef.automate.api.ingest.request.Action\x1a<.chef.automate.api.ingest.response.ProcessChefActionResponse\"%\x82\xd3\xe4\x93\x02\x1f:\x01*\"\x1a/api/v0/events/chef/action\x12\xa6\x01\n" +
	"\x13ProcessLivenessPing\x12*.chef.automate.api.ingest.request.Liveness\x1a:.chef.automate.api.ingest.response.ProcessLivenessResponse\"'\x82\xd3\xe4\x93\x02!:\x01*\"\x1c/api/v0/events/chef/liveness\x12\x9f\x01\n" +
	"\x1aProcessMultipleNodeDeletes\x12;.chef.automate.api.ingest.request.MultipleNodeDeleteRequest\x1aD.chef.automate.api.ingest.response.ProcessMultipleNodeDeleteResponse\x12\xa6\x01\n" +
	"\x11ProcessNodeDelete\x12(.chef.automate.api.ingest.request.Delete\x1a<.chef.automate.api.ingest.response.ProcessNodeDeleteResponse\")\x82\xd3\xe4\x93\x02#:\x01*\"\x1e/api/v0/events/chef/nodedelete\x12\x7f\n" +
	"\n" +
	"GetVersion\x12+.chef.automate.domain.ingest.VersionRequest\x1a$.chef.automate.domain.ingest.Version\"\x1e\x82\xd3\xe4\x93\x02\x18\x12\x16/api/v0/ingest/version\x12\x99\x01\n" +
	"\fStartReindex\x120.chef.automate.domain.ingest.StartReindexRequest\x1a1.chef.automate.domain.ingest.StartReindexResponse\"$\x82\xd3\xe4\x93\x02\x1e\"\x1c/api/v0/ingest/reindex/start\x12\xa6\x01\n" +
	"\x10GetReindexStatus\x124.chef.automate.domain.ingest.GetReindexStatusRequest\x1a5.chef.automate.domain.ingest.GetReindexStatusResponse\"%\x82\xd3\xe4\x93\x02\x1f\x12\x1d/api/v0/ingest/reindex/statusB2Z0github.com/chef/automate/api/interservice/ingestb\x06proto3"

var (
	file_interservice_ingest_chef_proto_rawDescOnce sync.Once
	file_interservice_ingest_chef_proto_rawDescData []byte
)

func file_interservice_ingest_chef_proto_rawDescGZIP() []byte {
	file_interservice_ingest_chef_proto_rawDescOnce.Do(func() {
		file_interservice_ingest_chef_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_interservice_ingest_chef_proto_rawDesc), len(file_interservice_ingest_chef_proto_rawDesc)))
	})
	return file_interservice_ingest_chef_proto_rawDescData
}

var file_interservice_ingest_chef_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
var file_interservice_ingest_chef_proto_goTypes = []any{
	(*Version)(nil),                                    // 0: chef.automate.domain.ingest.Version
	(*VersionRequest)(nil),                             // 1: chef.automate.domain.ingest.VersionRequest
	(*StartReindexRequest)(nil),                        // 2: chef.automate.domain.ingest.StartReindexRequest
	(*StartReindexResponse)(nil),                       // 3: chef.automate.domain.ingest.StartReindexResponse
	(*GetReindexStatusResponse)(nil),                   // 4: chef.automate.domain.ingest.GetReindexStatusResponse
	(*GetReindexStatusRequest)(nil),                    // 5: chef.automate.domain.ingest.GetReindexStatusRequest
	(*request.Run)(nil),                                // 6: chef.automate.api.ingest.request.Run
	(*request.Action)(nil),                             // 7: chef.automate.api.ingest.request.Action
	(*request.Liveness)(nil),                           // 8: chef.automate.api.ingest.request.Liveness
	(*request.MultipleNodeDeleteRequest)(nil),          // 9: chef.automate.api.ingest.request.MultipleNodeDeleteRequest
	(*request.Delete)(nil),                             // 10: chef.automate.api.ingest.request.Delete
	(*response.ProcessChefRunResponse)(nil),            // 11: chef.automate.api.ingest.response.ProcessChefRunResponse
	(*response.ProcessChefActionResponse)(nil),         // 12: chef.automate.api.ingest.response.ProcessChefActionResponse
	(*response.ProcessLivenessResponse)(nil),           // 13: chef.automate.api.ingest.response.ProcessLivenessResponse
	(*response.ProcessMultipleNodeDeleteResponse)(nil), // 14: chef.automate.api.ingest.response.ProcessMultipleNodeDeleteResponse
	(*response.ProcessNodeDeleteResponse)(nil),         // 15: chef.automate.api.ingest.response.ProcessNodeDeleteResponse
}
var file_interservice_ingest_chef_proto_depIdxs = []int32{
	6,  // 0: chef.automate.domain.ingest.ChefIngesterService.ProcessChefRun:input_type -> chef.automate.api.ingest.request.Run
	7,  // 1: chef.automate.domain.ingest.ChefIngesterService.ProcessChefAction:input_type -> chef.automate.api.ingest.request.Action
	8,  // 2: chef.automate.domain.ingest.ChefIngesterService.ProcessLivenessPing:input_type -> chef.automate.api.ingest.request.Liveness
	9,  // 3: chef.automate.domain.ingest.ChefIngesterService.ProcessMultipleNodeDeletes:input_type -> chef.automate.api.ingest.request.MultipleNodeDeleteRequest
	10, // 4: chef.automate.domain.ingest.ChefIngesterService.ProcessNodeDelete:input_type -> chef.automate.api.ingest.request.Delete
	1,  // 5: chef.automate.domain.ingest.ChefIngesterService.GetVersion:input_type -> chef.automate.domain.ingest.VersionRequest
	2,  // 6: chef.automate.domain.ingest.ChefIngesterService.StartReindex:input_type -> chef.automate.domain.ingest.StartReindexRequest
	5,  // 7: chef.automate.domain.ingest.ChefIngesterService.GetReindexStatus:input_type -> chef.automate.domain.ingest.GetReindexStatusRequest
	11, // 8: chef.automate.domain.ingest.ChefIngesterService.ProcessChefRun:output_type -> chef.automate.api.ingest.response.ProcessChefRunResponse
	12, // 9: chef.automate.domain.ingest.ChefIngesterService.ProcessChefAction:output_type -> chef.automate.api.ingest.response.ProcessChefActionResponse
	13, // 10: chef.automate.domain.ingest.ChefIngesterService.ProcessLivenessPing:output_type -> chef.automate.api.ingest.response.ProcessLivenessResponse
	14, // 11: chef.automate.domain.ingest.ChefIngesterService.ProcessMultipleNodeDeletes:output_type -> chef.automate.api.ingest.response.ProcessMultipleNodeDeleteResponse
	15, // 12: chef.automate.domain.ingest.ChefIngesterService.ProcessNodeDelete:output_type -> chef.automate.api.ingest.response.ProcessNodeDeleteResponse
	0,  // 13: chef.automate.domain.ingest.ChefIngesterService.GetVersion:output_type -> chef.automate.domain.ingest.Version
	3,  // 14: chef.automate.domain.ingest.ChefIngesterService.StartReindex:output_type -> chef.automate.domain.ingest.StartReindexResponse
	4,  // 15: chef.automate.domain.ingest.ChefIngesterService.GetReindexStatus:output_type -> chef.automate.domain.ingest.GetReindexStatusResponse
	8,  // [8:16] is the sub-list for method output_type
	0,  // [0:8] is the sub-list for method input_type
	0,  // [0:0] is the sub-list for extension type_name
	0,  // [0:0] is the sub-list for extension extendee
	0,  // [0:0] is the sub-list for field type_name
}

func init() { file_interservice_ingest_chef_proto_init() }
func file_interservice_ingest_chef_proto_init() {
	if File_interservice_ingest_chef_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_interservice_ingest_chef_proto_rawDesc), len(file_interservice_ingest_chef_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   6,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_interservice_ingest_chef_proto_goTypes,
		DependencyIndexes: file_interservice_ingest_chef_proto_depIdxs,
		MessageInfos:      file_interservice_ingest_chef_proto_msgTypes,
	}.Build()
	File_interservice_ingest_chef_proto = out.File
	file_interservice_ingest_chef_proto_goTypes = nil
	file_interservice_ingest_chef_proto_depIdxs = nil
}

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

// ChefIngesterServiceClient is the client API for ChefIngesterService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ChefIngesterServiceClient interface {
	ProcessChefRun(ctx context.Context, in *request.Run, opts ...grpc.CallOption) (*response.ProcessChefRunResponse, error)
	ProcessChefAction(ctx context.Context, in *request.Action, opts ...grpc.CallOption) (*response.ProcessChefActionResponse, error)
	ProcessLivenessPing(ctx context.Context, in *request.Liveness, opts ...grpc.CallOption) (*response.ProcessLivenessResponse, error)
	ProcessMultipleNodeDeletes(ctx context.Context, in *request.MultipleNodeDeleteRequest, opts ...grpc.CallOption) (*response.ProcessMultipleNodeDeleteResponse, error)
	ProcessNodeDelete(ctx context.Context, in *request.Delete, opts ...grpc.CallOption) (*response.ProcessNodeDeleteResponse, error)
	GetVersion(ctx context.Context, in *VersionRequest, opts ...grpc.CallOption) (*Version, error)
	StartReindex(ctx context.Context, in *StartReindexRequest, opts ...grpc.CallOption) (*StartReindexResponse, error)
	GetReindexStatus(ctx context.Context, in *GetReindexStatusRequest, opts ...grpc.CallOption) (*GetReindexStatusResponse, error)
}

type chefIngesterServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewChefIngesterServiceClient(cc grpc.ClientConnInterface) ChefIngesterServiceClient {
	return &chefIngesterServiceClient{cc}
}

func (c *chefIngesterServiceClient) ProcessChefRun(ctx context.Context, in *request.Run, opts ...grpc.CallOption) (*response.ProcessChefRunResponse, error) {
	out := new(response.ProcessChefRunResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.domain.ingest.ChefIngesterService/ProcessChefRun", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chefIngesterServiceClient) ProcessChefAction(ctx context.Context, in *request.Action, opts ...grpc.CallOption) (*response.ProcessChefActionResponse, error) {
	out := new(response.ProcessChefActionResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.domain.ingest.ChefIngesterService/ProcessChefAction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chefIngesterServiceClient) ProcessLivenessPing(ctx context.Context, in *request.Liveness, opts ...grpc.CallOption) (*response.ProcessLivenessResponse, error) {
	out := new(response.ProcessLivenessResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.domain.ingest.ChefIngesterService/ProcessLivenessPing", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chefIngesterServiceClient) ProcessMultipleNodeDeletes(ctx context.Context, in *request.MultipleNodeDeleteRequest, opts ...grpc.CallOption) (*response.ProcessMultipleNodeDeleteResponse, error) {
	out := new(response.ProcessMultipleNodeDeleteResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.domain.ingest.ChefIngesterService/ProcessMultipleNodeDeletes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chefIngesterServiceClient) ProcessNodeDelete(ctx context.Context, in *request.Delete, opts ...grpc.CallOption) (*response.ProcessNodeDeleteResponse, error) {
	out := new(response.ProcessNodeDeleteResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.domain.ingest.ChefIngesterService/ProcessNodeDelete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chefIngesterServiceClient) GetVersion(ctx context.Context, in *VersionRequest, opts ...grpc.CallOption) (*Version, error) {
	out := new(Version)
	err := c.cc.Invoke(ctx, "/chef.automate.domain.ingest.ChefIngesterService/GetVersion", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chefIngesterServiceClient) StartReindex(ctx context.Context, in *StartReindexRequest, opts ...grpc.CallOption) (*StartReindexResponse, error) {
	out := new(StartReindexResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.domain.ingest.ChefIngesterService/StartReindex", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *chefIngesterServiceClient) GetReindexStatus(ctx context.Context, in *GetReindexStatusRequest, opts ...grpc.CallOption) (*GetReindexStatusResponse, error) {
	out := new(GetReindexStatusResponse)
	err := c.cc.Invoke(ctx, "/chef.automate.domain.ingest.ChefIngesterService/GetReindexStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ChefIngesterServiceServer is the server API for ChefIngesterService service.
type ChefIngesterServiceServer interface {
	ProcessChefRun(context.Context, *request.Run) (*response.ProcessChefRunResponse, error)
	ProcessChefAction(context.Context, *request.Action) (*response.ProcessChefActionResponse, error)
	ProcessLivenessPing(context.Context, *request.Liveness) (*response.ProcessLivenessResponse, error)
	ProcessMultipleNodeDeletes(context.Context, *request.MultipleNodeDeleteRequest) (*response.ProcessMultipleNodeDeleteResponse, error)
	ProcessNodeDelete(context.Context, *request.Delete) (*response.ProcessNodeDeleteResponse, error)
	GetVersion(context.Context, *VersionRequest) (*Version, error)
	StartReindex(context.Context, *StartReindexRequest) (*StartReindexResponse, error)
	GetReindexStatus(context.Context, *GetReindexStatusRequest) (*GetReindexStatusResponse, error)
}

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

func (*UnimplementedChefIngesterServiceServer) ProcessChefRun(context.Context, *request.Run) (*response.ProcessChefRunResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessChefRun not implemented")
}
func (*UnimplementedChefIngesterServiceServer) ProcessChefAction(context.Context, *request.Action) (*response.ProcessChefActionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessChefAction not implemented")
}
func (*UnimplementedChefIngesterServiceServer) ProcessLivenessPing(context.Context, *request.Liveness) (*response.ProcessLivenessResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessLivenessPing not implemented")
}
func (*UnimplementedChefIngesterServiceServer) ProcessMultipleNodeDeletes(context.Context, *request.MultipleNodeDeleteRequest) (*response.ProcessMultipleNodeDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessMultipleNodeDeletes not implemented")
}
func (*UnimplementedChefIngesterServiceServer) ProcessNodeDelete(context.Context, *request.Delete) (*response.ProcessNodeDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessNodeDelete not implemented")
}
func (*UnimplementedChefIngesterServiceServer) GetVersion(context.Context, *VersionRequest) (*Version, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVersion not implemented")
}
func (*UnimplementedChefIngesterServiceServer) StartReindex(context.Context, *StartReindexRequest) (*StartReindexResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartReindex not implemented")
}
func (*UnimplementedChefIngesterServiceServer) GetReindexStatus(context.Context, *GetReindexStatusRequest) (*GetReindexStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetReindexStatus not implemented")
}

func RegisterChefIngesterServiceServer(s *grpc.Server, srv ChefIngesterServiceServer) {
	s.RegisterService(&_ChefIngesterService_serviceDesc, srv)
}

func _ChefIngesterService_ProcessChefRun_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(request.Run)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChefIngesterServiceServer).ProcessChefRun(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.domain.ingest.ChefIngesterService/ProcessChefRun",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChefIngesterServiceServer).ProcessChefRun(ctx, req.(*request.Run))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChefIngesterService_ProcessChefAction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(request.Action)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChefIngesterServiceServer).ProcessChefAction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.domain.ingest.ChefIngesterService/ProcessChefAction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChefIngesterServiceServer).ProcessChefAction(ctx, req.(*request.Action))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChefIngesterService_ProcessLivenessPing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(request.Liveness)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChefIngesterServiceServer).ProcessLivenessPing(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.domain.ingest.ChefIngesterService/ProcessLivenessPing",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChefIngesterServiceServer).ProcessLivenessPing(ctx, req.(*request.Liveness))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChefIngesterService_ProcessMultipleNodeDeletes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(request.MultipleNodeDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChefIngesterServiceServer).ProcessMultipleNodeDeletes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.domain.ingest.ChefIngesterService/ProcessMultipleNodeDeletes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChefIngesterServiceServer).ProcessMultipleNodeDeletes(ctx, req.(*request.MultipleNodeDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChefIngesterService_ProcessNodeDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(request.Delete)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChefIngesterServiceServer).ProcessNodeDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.domain.ingest.ChefIngesterService/ProcessNodeDelete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChefIngesterServiceServer).ProcessNodeDelete(ctx, req.(*request.Delete))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChefIngesterService_GetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VersionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChefIngesterServiceServer).GetVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.domain.ingest.ChefIngesterService/GetVersion",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChefIngesterServiceServer).GetVersion(ctx, req.(*VersionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChefIngesterService_StartReindex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartReindexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChefIngesterServiceServer).StartReindex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.domain.ingest.ChefIngesterService/StartReindex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChefIngesterServiceServer).StartReindex(ctx, req.(*StartReindexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ChefIngesterService_GetReindexStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetReindexStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChefIngesterServiceServer).GetReindexStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.domain.ingest.ChefIngesterService/GetReindexStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChefIngesterServiceServer).GetReindexStatus(ctx, req.(*GetReindexStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ChefIngesterService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "chef.automate.domain.ingest.ChefIngesterService",
	HandlerType: (*ChefIngesterServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ProcessChefRun",
			Handler:    _ChefIngesterService_ProcessChefRun_Handler,
		},
		{
			MethodName: "ProcessChefAction",
			Handler:    _ChefIngesterService_ProcessChefAction_Handler,
		},
		{
			MethodName: "ProcessLivenessPing",
			Handler:    _ChefIngesterService_ProcessLivenessPing_Handler,
		},
		{
			MethodName: "ProcessMultipleNodeDeletes",
			Handler:    _ChefIngesterService_ProcessMultipleNodeDeletes_Handler,
		},
		{
			MethodName: "ProcessNodeDelete",
			Handler:    _ChefIngesterService_ProcessNodeDelete_Handler,
		},
		{
			MethodName: "GetVersion",
			Handler:    _ChefIngesterService_GetVersion_Handler,
		},
		{
			MethodName: "StartReindex",
			Handler:    _ChefIngesterService_StartReindex_Handler,
		},
		{
			MethodName: "GetReindexStatus",
			Handler:    _ChefIngesterService_GetReindexStatus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "interservice/ingest/chef.proto",
}
