rpc.pb.go

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

package rpcpb

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

func init() { proto.RegisterFile("matchbox/rpc/rpcpb/rpc.proto", fileDescriptor_16cc910f0e1e5aa8) }

var fileDescriptor_16cc910f0e1e5aa8 = []byte{
	// 430 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x94, 0xc1, 0x4e, 0xe3, 0x30,
	0x10, 0x86, 0xb7, 0x95, 0xb6, 0xdb, 0xf5, 0x6a, 0x39, 0xe4, 0x46, 0x49, 0x29, 0xe2, 0xc2, 0x2d,
	0x11, 0xe5, 0x0d, 0x00, 0x11, 0x55, 0xea, 0xa1, 0x2a, 0xe2, 0xc2, 0xad, 0x09, 0x43, 0x1b, 0xa9,
	0x8d, 0x43, 0xec, 0x20, 0x1e, 0x09, 0xf1, 0x18, 0xbc, 0x12, 0x67, 0x24, 0x64, 0xc7, 0x76, 0x26,
	0xb1, 0x7d, 0x68, 0x6b, 0xfd, 0x9f, 0xfd, 0x77, 0xf2, 0xcf, 0xc4, 0x24, 0x3c, 0x6c, 0x78, 0xb6,
	0x4b, 0xe9, 0x5b, 0x5c, 0x95, 0x99, 0xf8, 0x94, 0xa9, 0xf8, 0x8e, 0xca, 0x8a, 0x72, 0x1a, 0xfc,
	0x96, 0xc2, 0xe4, 0xc2, 0x6c, 0x62, 0x50, 0xbd, 0x42, 0xa5, 0x7e, 0xca, 0x34, 0x3e, 0x00, 0x63,
	0x9b, 0x2d, 0xb0, 0x66, 0xff, 0xfc, 0x7d, 0x48, 0x46, 0x49, 0x45, 0xeb, 0x92, 0x05, 0x37, 0x64,
	0x2c, 0x57, 0xab, 0x9a, 0x07, 0xc7, 0x91, 0x3e, 0x10, 0x69, 0x6d, 0x0d, 0x2f, 0x35, 0x30, 0x3e,
	0x99, 0xb8, 0x10, 0x2b, 0x69, 0xc1, 0xe0, 0xfc, 0x97, 0x31, 0x49, 0xc0, 0x36, 0x49, 0xc0, 0x6b,
	0x22, 0x91, 0x31, 0x59, 0x92, 0x7f, 0x52, 0xbd, 0x85, 0x3d, 0x70, 0x08, 0xc2, 0xde, 0xe6, 0x46,
	0xd6, 0x56, 0x53, 0x0f, 0x35, 0x6e, 0x77, 0xe4, 0xaf, 0x04, 0xcb, 0x9c, 0xf1, 0xa0, 0xff, 0xc7,
	0x42, 0xd4, 0x4e, 0x27, 0x4e, 0xa6, 0x7d, 0xe6, 0x9f, 0x43, 0x32, 0x5e, 0x55, 0xf4, 0x39, 0xdf,
	0x03, 0x0b, 0x16, 0x84, 0xa8, 0xb5, 0x88, 0x0b, 0x9d, 0x6c, 0x55, 0x6d, 0x1b, 0xba, 0xa1, 0xa9,
	0xaf, 0xb5, 0x12, 0xa1, 0xd9, 0x56, 0x28, 0xb6, 0xd0, 0x0d, 0x8d, 0xd5, 0x9a, 0xfc, 0x57, 0xba,
	0x8a, 0xee, 0xd4, 0x3a, 0xd0, 0x0d, 0x6f, 0xe6, 0xe5, 0xb8, 0x19, 0x0a, 0xc9, 0x00, 0xed, 0x12,
	0x70, 0x84, 0x53, 0x0f, 0x35, 0x21, 0x7e, 0x0f, 0xc8, 0x78, 0xb1, 0x2d, 0x72, 0x9e, 0xd3, 0x42,
	0x58, 0xeb, 0xb5, 0x48, 0x11, 0x59, 0x23, 0xd9, 0x61, 0xdd, 0xa1, 0xb8, 0x50, 0x0d, 0x44, 0x90,
	0x0e, 0x37, 0x94, 0xe4, 0xd4, 0x43, 0x8d, 0xdb, 0x03, 0x39, 0xd2, 0x40, 0x65, 0x39, 0xb3, 0x8f,
	0x74, 0xc3, 0x3c, 0xf3, 0x6f, 0x30, 0xcf, 0xff, 0x35, 0x20, 0x7f, 0x12, 0x28, 0xa0, 0xca, 0x33,
	0xd1, 0x78, 0xb5, 0xec, 0xcd, 0x50, 0xab, 0x3a, 0x1a, 0x8f, 0x21, 0x9e, 0x21, 0xa5, 0xf7, 0x66,
	0xa8, 0x55, 0xfd, 0x56, 0xd6, 0x0c, 0x29, 0xdd, 0x9e, 0xa1, 0x0e, 0x70, 0xcc, 0x50, 0x8f, 0x9b,
	0xa7, 0xfe, 0x18, 0x90, 0xd1, 0x3d, 0xec, 0x21, 0xe3, 0xa2, 0x4b, 0xcd, 0x4a, 0xbe, 0x62, 0xb8,
	0x4b, 0x48, 0x76, 0x74, 0xa9, 0x43, 0x71, 0xb1, 0x0d, 0x50, 0xd3, 0x86, 0x8b, 0xed, 0x00, 0x47,
	0xb1, 0x3d, 0xae, 0x3d, 0xaf, 0x2f, 0x1f, 0xe3, 0x6d, 0xce, 0x77, 0x75, 0x1a, 0x65, 0xf4, 0x10,
	0x97, 0x94, 0x41, 0xfe, 0x44, 0x8b, 0xd8, 0xdc, 0xa8, 0xf6, 0xfd, 0x9b, 0x8e, 0xe4, 0x65, 0x7a,
	0xf5, 0x13, 0x00, 0x00, 0xff, 0xff, 0x3e, 0x95, 0x02, 0xe5, 0x9c, 0x05, 0x00, 0x00,
}

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

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

// GroupsClient is the client API for Groups service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type GroupsClient interface {
	// Create a Group.
	GroupPut(ctx context.Context, in *serverpb.GroupPutRequest, opts ...grpc.CallOption) (*serverpb.GroupPutResponse, error)
	// Get a machine Group by id.
	GroupGet(ctx context.Context, in *serverpb.GroupGetRequest, opts ...grpc.CallOption) (*serverpb.GroupGetResponse, error)
	// Delete a machine Group by id.
	GroupDelete(ctx context.Context, in *serverpb.GroupDeleteRequest, opts ...grpc.CallOption) (*serverpb.GroupDeleteResponse, error)
	// List all machine Groups.
	GroupList(ctx context.Context, in *serverpb.GroupListRequest, opts ...grpc.CallOption) (*serverpb.GroupListResponse, error)
}

type groupsClient struct {
	cc *grpc.ClientConn
}

func NewGroupsClient(cc *grpc.ClientConn) GroupsClient {
	return &groupsClient{cc}
}

func (c *groupsClient) GroupPut(ctx context.Context, in *serverpb.GroupPutRequest, opts ...grpc.CallOption) (*serverpb.GroupPutResponse, error) {
	out := new(serverpb.GroupPutResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Groups/GroupPut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupsClient) GroupGet(ctx context.Context, in *serverpb.GroupGetRequest, opts ...grpc.CallOption) (*serverpb.GroupGetResponse, error) {
	out := new(serverpb.GroupGetResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Groups/GroupGet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupsClient) GroupDelete(ctx context.Context, in *serverpb.GroupDeleteRequest, opts ...grpc.CallOption) (*serverpb.GroupDeleteResponse, error) {
	out := new(serverpb.GroupDeleteResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Groups/GroupDelete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupsClient) GroupList(ctx context.Context, in *serverpb.GroupListRequest, opts ...grpc.CallOption) (*serverpb.GroupListResponse, error) {
	out := new(serverpb.GroupListResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Groups/GroupList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GroupsServer is the server API for Groups service.
type GroupsServer interface {
	// Create a Group.
	GroupPut(context.Context, *serverpb.GroupPutRequest) (*serverpb.GroupPutResponse, error)
	// Get a machine Group by id.
	GroupGet(context.Context, *serverpb.GroupGetRequest) (*serverpb.GroupGetResponse, error)
	// Delete a machine Group by id.
	GroupDelete(context.Context, *serverpb.GroupDeleteRequest) (*serverpb.GroupDeleteResponse, error)
	// List all machine Groups.
	GroupList(context.Context, *serverpb.GroupListRequest) (*serverpb.GroupListResponse, error)
}

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

func (*UnimplementedGroupsServer) GroupPut(ctx context.Context, req *serverpb.GroupPutRequest) (*serverpb.GroupPutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GroupPut not implemented")
}
func (*UnimplementedGroupsServer) GroupGet(ctx context.Context, req *serverpb.GroupGetRequest) (*serverpb.GroupGetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GroupGet not implemented")
}
func (*UnimplementedGroupsServer) GroupDelete(ctx context.Context, req *serverpb.GroupDeleteRequest) (*serverpb.GroupDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GroupDelete not implemented")
}
func (*UnimplementedGroupsServer) GroupList(ctx context.Context, req *serverpb.GroupListRequest) (*serverpb.GroupListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GroupList not implemented")
}

func RegisterGroupsServer(s *grpc.Server, srv GroupsServer) {
	s.RegisterService(&_Groups_serviceDesc, srv)
}

func _Groups_GroupPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.GroupPutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GroupsServer).GroupPut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Groups/GroupPut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupsServer).GroupPut(ctx, req.(*serverpb.GroupPutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Groups_GroupGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.GroupGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GroupsServer).GroupGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Groups/GroupGet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupsServer).GroupGet(ctx, req.(*serverpb.GroupGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Groups_GroupDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.GroupDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GroupsServer).GroupDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Groups/GroupDelete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupsServer).GroupDelete(ctx, req.(*serverpb.GroupDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Groups_GroupList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.GroupListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GroupsServer).GroupList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Groups/GroupList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupsServer).GroupList(ctx, req.(*serverpb.GroupListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Groups_serviceDesc = grpc.ServiceDesc{
	ServiceName: "rpcpb.Groups",
	HandlerType: (*GroupsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GroupPut",
			Handler:    _Groups_GroupPut_Handler,
		},
		{
			MethodName: "GroupGet",
			Handler:    _Groups_GroupGet_Handler,
		},
		{
			MethodName: "GroupDelete",
			Handler:    _Groups_GroupDelete_Handler,
		},
		{
			MethodName: "GroupList",
			Handler:    _Groups_GroupList_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "matchbox/rpc/rpcpb/rpc.proto",
}

// ProfilesClient is the client API for Profiles service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ProfilesClient interface {
	// Create a Profile.
	ProfilePut(ctx context.Context, in *serverpb.ProfilePutRequest, opts ...grpc.CallOption) (*serverpb.ProfilePutResponse, error)
	// Get a Profile by id.
	ProfileGet(ctx context.Context, in *serverpb.ProfileGetRequest, opts ...grpc.CallOption) (*serverpb.ProfileGetResponse, error)
	// Delete a Profile by id.
	ProfileDelete(ctx context.Context, in *serverpb.ProfileDeleteRequest, opts ...grpc.CallOption) (*serverpb.ProfileDeleteResponse, error)
	// List all Profiles.
	ProfileList(ctx context.Context, in *serverpb.ProfileListRequest, opts ...grpc.CallOption) (*serverpb.ProfileListResponse, error)
}

type profilesClient struct {
	cc *grpc.ClientConn
}

func NewProfilesClient(cc *grpc.ClientConn) ProfilesClient {
	return &profilesClient{cc}
}

func (c *profilesClient) ProfilePut(ctx context.Context, in *serverpb.ProfilePutRequest, opts ...grpc.CallOption) (*serverpb.ProfilePutResponse, error) {
	out := new(serverpb.ProfilePutResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Profiles/ProfilePut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *profilesClient) ProfileGet(ctx context.Context, in *serverpb.ProfileGetRequest, opts ...grpc.CallOption) (*serverpb.ProfileGetResponse, error) {
	out := new(serverpb.ProfileGetResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Profiles/ProfileGet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *profilesClient) ProfileDelete(ctx context.Context, in *serverpb.ProfileDeleteRequest, opts ...grpc.CallOption) (*serverpb.ProfileDeleteResponse, error) {
	out := new(serverpb.ProfileDeleteResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Profiles/ProfileDelete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *profilesClient) ProfileList(ctx context.Context, in *serverpb.ProfileListRequest, opts ...grpc.CallOption) (*serverpb.ProfileListResponse, error) {
	out := new(serverpb.ProfileListResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Profiles/ProfileList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ProfilesServer is the server API for Profiles service.
type ProfilesServer interface {
	// Create a Profile.
	ProfilePut(context.Context, *serverpb.ProfilePutRequest) (*serverpb.ProfilePutResponse, error)
	// Get a Profile by id.
	ProfileGet(context.Context, *serverpb.ProfileGetRequest) (*serverpb.ProfileGetResponse, error)
	// Delete a Profile by id.
	ProfileDelete(context.Context, *serverpb.ProfileDeleteRequest) (*serverpb.ProfileDeleteResponse, error)
	// List all Profiles.
	ProfileList(context.Context, *serverpb.ProfileListRequest) (*serverpb.ProfileListResponse, error)
}

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

func (*UnimplementedProfilesServer) ProfilePut(ctx context.Context, req *serverpb.ProfilePutRequest) (*serverpb.ProfilePutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProfilePut not implemented")
}
func (*UnimplementedProfilesServer) ProfileGet(ctx context.Context, req *serverpb.ProfileGetRequest) (*serverpb.ProfileGetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProfileGet not implemented")
}
func (*UnimplementedProfilesServer) ProfileDelete(ctx context.Context, req *serverpb.ProfileDeleteRequest) (*serverpb.ProfileDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProfileDelete not implemented")
}
func (*UnimplementedProfilesServer) ProfileList(ctx context.Context, req *serverpb.ProfileListRequest) (*serverpb.ProfileListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProfileList not implemented")
}

func RegisterProfilesServer(s *grpc.Server, srv ProfilesServer) {
	s.RegisterService(&_Profiles_serviceDesc, srv)
}

func _Profiles_ProfilePut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.ProfilePutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProfilesServer).ProfilePut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Profiles/ProfilePut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProfilesServer).ProfilePut(ctx, req.(*serverpb.ProfilePutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Profiles_ProfileGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.ProfileGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProfilesServer).ProfileGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Profiles/ProfileGet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProfilesServer).ProfileGet(ctx, req.(*serverpb.ProfileGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Profiles_ProfileDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.ProfileDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProfilesServer).ProfileDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Profiles/ProfileDelete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProfilesServer).ProfileDelete(ctx, req.(*serverpb.ProfileDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Profiles_ProfileList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.ProfileListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProfilesServer).ProfileList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Profiles/ProfileList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProfilesServer).ProfileList(ctx, req.(*serverpb.ProfileListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Profiles_serviceDesc = grpc.ServiceDesc{
	ServiceName: "rpcpb.Profiles",
	HandlerType: (*ProfilesServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ProfilePut",
			Handler:    _Profiles_ProfilePut_Handler,
		},
		{
			MethodName: "ProfileGet",
			Handler:    _Profiles_ProfileGet_Handler,
		},
		{
			MethodName: "ProfileDelete",
			Handler:    _Profiles_ProfileDelete_Handler,
		},
		{
			MethodName: "ProfileList",
			Handler:    _Profiles_ProfileList_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "matchbox/rpc/rpcpb/rpc.proto",
}

// IgnitionClient is the client API for Ignition service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type IgnitionClient interface {
	// Create or update a Container Linux Config template.
	IgnitionPut(ctx context.Context, in *serverpb.IgnitionPutRequest, opts ...grpc.CallOption) (*serverpb.IgnitionPutResponse, error)
	// Get a Container Linux Config template by name.
	IgnitionGet(ctx context.Context, in *serverpb.IgnitionGetRequest, opts ...grpc.CallOption) (*serverpb.IgnitionGetResponse, error)
	// Delete a Container Linux Config template by name.
	IgnitionDelete(ctx context.Context, in *serverpb.IgnitionDeleteRequest, opts ...grpc.CallOption) (*serverpb.IgnitionDeleteResponse, error)
}

type ignitionClient struct {
	cc *grpc.ClientConn
}

func NewIgnitionClient(cc *grpc.ClientConn) IgnitionClient {
	return &ignitionClient{cc}
}

func (c *ignitionClient) IgnitionPut(ctx context.Context, in *serverpb.IgnitionPutRequest, opts ...grpc.CallOption) (*serverpb.IgnitionPutResponse, error) {
	out := new(serverpb.IgnitionPutResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Ignition/IgnitionPut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ignitionClient) IgnitionGet(ctx context.Context, in *serverpb.IgnitionGetRequest, opts ...grpc.CallOption) (*serverpb.IgnitionGetResponse, error) {
	out := new(serverpb.IgnitionGetResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Ignition/IgnitionGet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ignitionClient) IgnitionDelete(ctx context.Context, in *serverpb.IgnitionDeleteRequest, opts ...grpc.CallOption) (*serverpb.IgnitionDeleteResponse, error) {
	out := new(serverpb.IgnitionDeleteResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Ignition/IgnitionDelete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// IgnitionServer is the server API for Ignition service.
type IgnitionServer interface {
	// Create or update a Container Linux Config template.
	IgnitionPut(context.Context, *serverpb.IgnitionPutRequest) (*serverpb.IgnitionPutResponse, error)
	// Get a Container Linux Config template by name.
	IgnitionGet(context.Context, *serverpb.IgnitionGetRequest) (*serverpb.IgnitionGetResponse, error)
	// Delete a Container Linux Config template by name.
	IgnitionDelete(context.Context, *serverpb.IgnitionDeleteRequest) (*serverpb.IgnitionDeleteResponse, error)
}

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

func (*UnimplementedIgnitionServer) IgnitionPut(ctx context.Context, req *serverpb.IgnitionPutRequest) (*serverpb.IgnitionPutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IgnitionPut not implemented")
}
func (*UnimplementedIgnitionServer) IgnitionGet(ctx context.Context, req *serverpb.IgnitionGetRequest) (*serverpb.IgnitionGetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IgnitionGet not implemented")
}
func (*UnimplementedIgnitionServer) IgnitionDelete(ctx context.Context, req *serverpb.IgnitionDeleteRequest) (*serverpb.IgnitionDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IgnitionDelete not implemented")
}

func RegisterIgnitionServer(s *grpc.Server, srv IgnitionServer) {
	s.RegisterService(&_Ignition_serviceDesc, srv)
}

func _Ignition_IgnitionPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.IgnitionPutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IgnitionServer).IgnitionPut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Ignition/IgnitionPut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IgnitionServer).IgnitionPut(ctx, req.(*serverpb.IgnitionPutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ignition_IgnitionGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.IgnitionGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IgnitionServer).IgnitionGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Ignition/IgnitionGet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IgnitionServer).IgnitionGet(ctx, req.(*serverpb.IgnitionGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ignition_IgnitionDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.IgnitionDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IgnitionServer).IgnitionDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Ignition/IgnitionDelete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IgnitionServer).IgnitionDelete(ctx, req.(*serverpb.IgnitionDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Ignition_serviceDesc = grpc.ServiceDesc{
	ServiceName: "rpcpb.Ignition",
	HandlerType: (*IgnitionServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "IgnitionPut",
			Handler:    _Ignition_IgnitionPut_Handler,
		},
		{
			MethodName: "IgnitionGet",
			Handler:    _Ignition_IgnitionGet_Handler,
		},
		{
			MethodName: "IgnitionDelete",
			Handler:    _Ignition_IgnitionDelete_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "matchbox/rpc/rpcpb/rpc.proto",
}

// GenericClient is the client API for Generic service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type GenericClient interface {
	// Create or update a Generic template.
	GenericPut(ctx context.Context, in *serverpb.GenericPutRequest, opts ...grpc.CallOption) (*serverpb.GenericPutResponse, error)
	// Get a Generic template by name.
	GenericGet(ctx context.Context, in *serverpb.GenericGetRequest, opts ...grpc.CallOption) (*serverpb.GenericGetResponse, error)
	// Delete a Generic template by name.
	GenericDelete(ctx context.Context, in *serverpb.GenericDeleteRequest, opts ...grpc.CallOption) (*serverpb.GenericDeleteResponse, error)
}

type genericClient struct {
	cc *grpc.ClientConn
}

func NewGenericClient(cc *grpc.ClientConn) GenericClient {
	return &genericClient{cc}
}

func (c *genericClient) GenericPut(ctx context.Context, in *serverpb.GenericPutRequest, opts ...grpc.CallOption) (*serverpb.GenericPutResponse, error) {
	out := new(serverpb.GenericPutResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Generic/GenericPut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *genericClient) GenericGet(ctx context.Context, in *serverpb.GenericGetRequest, opts ...grpc.CallOption) (*serverpb.GenericGetResponse, error) {
	out := new(serverpb.GenericGetResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Generic/GenericGet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *genericClient) GenericDelete(ctx context.Context, in *serverpb.GenericDeleteRequest, opts ...grpc.CallOption) (*serverpb.GenericDeleteResponse, error) {
	out := new(serverpb.GenericDeleteResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Generic/GenericDelete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GenericServer is the server API for Generic service.
type GenericServer interface {
	// Create or update a Generic template.
	GenericPut(context.Context, *serverpb.GenericPutRequest) (*serverpb.GenericPutResponse, error)
	// Get a Generic template by name.
	GenericGet(context.Context, *serverpb.GenericGetRequest) (*serverpb.GenericGetResponse, error)
	// Delete a Generic template by name.
	GenericDelete(context.Context, *serverpb.GenericDeleteRequest) (*serverpb.GenericDeleteResponse, error)
}

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

func (*UnimplementedGenericServer) GenericPut(ctx context.Context, req *serverpb.GenericPutRequest) (*serverpb.GenericPutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenericPut not implemented")
}
func (*UnimplementedGenericServer) GenericGet(ctx context.Context, req *serverpb.GenericGetRequest) (*serverpb.GenericGetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenericGet not implemented")
}
func (*UnimplementedGenericServer) GenericDelete(ctx context.Context, req *serverpb.GenericDeleteRequest) (*serverpb.GenericDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenericDelete not implemented")
}

func RegisterGenericServer(s *grpc.Server, srv GenericServer) {
	s.RegisterService(&_Generic_serviceDesc, srv)
}

func _Generic_GenericPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.GenericPutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GenericServer).GenericPut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Generic/GenericPut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GenericServer).GenericPut(ctx, req.(*serverpb.GenericPutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Generic_GenericGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.GenericGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GenericServer).GenericGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Generic/GenericGet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GenericServer).GenericGet(ctx, req.(*serverpb.GenericGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Generic_GenericDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.GenericDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GenericServer).GenericDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Generic/GenericDelete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GenericServer).GenericDelete(ctx, req.(*serverpb.GenericDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Generic_serviceDesc = grpc.ServiceDesc{
	ServiceName: "rpcpb.Generic",
	HandlerType: (*GenericServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GenericPut",
			Handler:    _Generic_GenericPut_Handler,
		},
		{
			MethodName: "GenericGet",
			Handler:    _Generic_GenericGet_Handler,
		},
		{
			MethodName: "GenericDelete",
			Handler:    _Generic_GenericDelete_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "matchbox/rpc/rpcpb/rpc.proto",
}

// SelectClient is the client API for Select service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SelectClient interface {
	// SelectGroup returns the Group matching the given labels.
	SelectGroup(ctx context.Context, in *serverpb.SelectGroupRequest, opts ...grpc.CallOption) (*serverpb.SelectGroupResponse, error)
	// SelectProfile returns the Profile matching the given labels.
	SelectProfile(ctx context.Context, in *serverpb.SelectProfileRequest, opts ...grpc.CallOption) (*serverpb.SelectProfileResponse, error)
}

type selectClient struct {
	cc *grpc.ClientConn
}

func NewSelectClient(cc *grpc.ClientConn) SelectClient {
	return &selectClient{cc}
}

func (c *selectClient) SelectGroup(ctx context.Context, in *serverpb.SelectGroupRequest, opts ...grpc.CallOption) (*serverpb.SelectGroupResponse, error) {
	out := new(serverpb.SelectGroupResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Select/SelectGroup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *selectClient) SelectProfile(ctx context.Context, in *serverpb.SelectProfileRequest, opts ...grpc.CallOption) (*serverpb.SelectProfileResponse, error) {
	out := new(serverpb.SelectProfileResponse)
	err := c.cc.Invoke(ctx, "/rpcpb.Select/SelectProfile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SelectServer is the server API for Select service.
type SelectServer interface {
	// SelectGroup returns the Group matching the given labels.
	SelectGroup(context.Context, *serverpb.SelectGroupRequest) (*serverpb.SelectGroupResponse, error)
	// SelectProfile returns the Profile matching the given labels.
	SelectProfile(context.Context, *serverpb.SelectProfileRequest) (*serverpb.SelectProfileResponse, error)
}

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

func (*UnimplementedSelectServer) SelectGroup(ctx context.Context, req *serverpb.SelectGroupRequest) (*serverpb.SelectGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SelectGroup not implemented")
}
func (*UnimplementedSelectServer) SelectProfile(ctx context.Context, req *serverpb.SelectProfileRequest) (*serverpb.SelectProfileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SelectProfile not implemented")
}

func RegisterSelectServer(s *grpc.Server, srv SelectServer) {
	s.RegisterService(&_Select_serviceDesc, srv)
}

func _Select_SelectGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.SelectGroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SelectServer).SelectGroup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Select/SelectGroup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SelectServer).SelectGroup(ctx, req.(*serverpb.SelectGroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Select_SelectProfile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(serverpb.SelectProfileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SelectServer).SelectProfile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpcpb.Select/SelectProfile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SelectServer).SelectProfile(ctx, req.(*serverpb.SelectProfileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Select_serviceDesc = grpc.ServiceDesc{
	ServiceName: "rpcpb.Select",
	HandlerType: (*SelectServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SelectGroup",
			Handler:    _Select_SelectGroup_Handler,
		},
		{
			MethodName: "SelectProfile",
			Handler:    _Select_SelectProfile_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "matchbox/rpc/rpcpb/rpc.proto",
}