// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.2
// - protoc             (unknown)
// source: remoteprovision.proto

package api

import (
	context "context"

	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	RemoteProvisionService_Ping_FullMethodName              = "/remoteprovision.RemoteProvisionService/Ping"
	RemoteProvisionService_Create_FullMethodName            = "/remoteprovision.RemoteProvisionService/Create"
	RemoteProvisionService_Destroy_FullMethodName           = "/remoteprovision.RemoteProvisionService/Destroy"
	RemoteProvisionService_Reflect_FullMethodName           = "/remoteprovision.RemoteProvisionService/Reflect"
	RemoteProvisionService_StreamLogs_FullMethodName        = "/remoteprovision.RemoteProvisionService/StreamLogs"
	RemoteProvisionService_StatArtifact_FullMethodName      = "/remoteprovision.RemoteProvisionService/StatArtifact"
	RemoteProvisionService_UploadArtifact_FullMethodName    = "/remoteprovision.RemoteProvisionService/UploadArtifact"
	RemoteProvisionService_SyncBootArtifacts_FullMethodName = "/remoteprovision.RemoteProvisionService/SyncBootArtifacts"
	RemoteProvisionService_Reboot_FullMethodName            = "/remoteprovision.RemoteProvisionService/Reboot"
	RemoteProvisionService_ProbeHTTP_FullMethodName         = "/remoteprovision.RemoteProvisionService/ProbeHTTP"
)

// RemoteProvisionServiceClient is the client API for RemoteProvisionService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
//
// RemoteProvisionService is the gRPC interface to a remote `talosctl
// cluster create` provisioner — the cluster-equivalent of a BuildKit
// remote builder. It is consumed by the `remote` provisioner under
// pkg/provision/providers/remote and served by `talosctl
// remote-provision-launch`.
//
// The server owns the QEMU lifecycle, the state directory, and the bridge
// network. RPC payloads carrying provision.ClusterRequest / provision.Cluster
// are JSON-encoded; the server unmarshals them and hands them to the
// in-process QEMU provisioner unchanged.
type RemoteProvisionServiceClient interface {
	// Ping returns server identity for connectivity sanity checks.
	Ping(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*PingResponse, error)
	// Create provisions a cluster. The stream emits progress events; the
	// terminal event carries the JSON-encoded provision.Cluster.
	Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CreateEvent], error)
	// Destroy tears down a previously-created cluster.
	Destroy(ctx context.Context, in *DestroyRequest, opts ...grpc.CallOption) (*DestroyResponse, error)
	// Reflect returns a previously-created cluster's state by name.
	Reflect(ctx context.Context, in *ReflectRequest, opts ...grpc.CallOption) (*ReflectResponse, error)
	// StreamLogs tails a machine's QEMU console log from the server's state
	// directory — the remote equivalent of `tail -F <machine>.log`.
	StreamLogs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[LogData], error)
	// StatArtifact reports whether a content-addressed artifact is already
	// cached on the server, so the client can skip re-uploading it.
	StatArtifact(ctx context.Context, in *StatArtifactRequest, opts ...grpc.CallOption) (*StatArtifactResponse, error)
	// UploadArtifact streams a boot artifact (kernel, initramfs, ISO, ...)
	// to the server's content-addressed cache. The first frame carries the
	// sha256; the rest carry data.
	UploadArtifact(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[ArtifactChunk, ArtifactRef], error)
	// SyncBootArtifacts updates the stable kernel and initramfs references
	// used by an existing no-bootloader cluster.
	SyncBootArtifacts(ctx context.Context, in *SyncBootArtifactsRequest, opts ...grpc.CallOption) (*SyncBootArtifactsResponse, error)
	// Reboot forcefully restarts one QEMU node.
	Reboot(ctx context.Context, in *RebootRequest, opts ...grpc.CallOption) (*RebootResponse, error)
	// ProbeHTTP performs a bounded HTTP GET from the provisioner host network namespace.
	ProbeHTTP(ctx context.Context, in *ProbeHTTPRequest, opts ...grpc.CallOption) (*ProbeHTTPResponse, error)
}

type remoteProvisionServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewRemoteProvisionServiceClient(cc grpc.ClientConnInterface) RemoteProvisionServiceClient {
	return &remoteProvisionServiceClient{cc}
}

func (c *remoteProvisionServiceClient) Ping(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*PingResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PingResponse)
	err := c.cc.Invoke(ctx, RemoteProvisionService_Ping_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *remoteProvisionServiceClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CreateEvent], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &RemoteProvisionService_ServiceDesc.Streams[0], RemoteProvisionService_Create_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[CreateRequest, CreateEvent]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type RemoteProvisionService_CreateClient = grpc.ServerStreamingClient[CreateEvent]

func (c *remoteProvisionServiceClient) Destroy(ctx context.Context, in *DestroyRequest, opts ...grpc.CallOption) (*DestroyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DestroyResponse)
	err := c.cc.Invoke(ctx, RemoteProvisionService_Destroy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *remoteProvisionServiceClient) Reflect(ctx context.Context, in *ReflectRequest, opts ...grpc.CallOption) (*ReflectResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ReflectResponse)
	err := c.cc.Invoke(ctx, RemoteProvisionService_Reflect_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *remoteProvisionServiceClient) StreamLogs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[LogData], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &RemoteProvisionService_ServiceDesc.Streams[1], RemoteProvisionService_StreamLogs_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[LogsRequest, LogData]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type RemoteProvisionService_StreamLogsClient = grpc.ServerStreamingClient[LogData]

func (c *remoteProvisionServiceClient) StatArtifact(ctx context.Context, in *StatArtifactRequest, opts ...grpc.CallOption) (*StatArtifactResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StatArtifactResponse)
	err := c.cc.Invoke(ctx, RemoteProvisionService_StatArtifact_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *remoteProvisionServiceClient) UploadArtifact(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[ArtifactChunk, ArtifactRef], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &RemoteProvisionService_ServiceDesc.Streams[2], RemoteProvisionService_UploadArtifact_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ArtifactChunk, ArtifactRef]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type RemoteProvisionService_UploadArtifactClient = grpc.ClientStreamingClient[ArtifactChunk, ArtifactRef]

func (c *remoteProvisionServiceClient) SyncBootArtifacts(ctx context.Context, in *SyncBootArtifactsRequest, opts ...grpc.CallOption) (*SyncBootArtifactsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SyncBootArtifactsResponse)
	err := c.cc.Invoke(ctx, RemoteProvisionService_SyncBootArtifacts_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *remoteProvisionServiceClient) Reboot(ctx context.Context, in *RebootRequest, opts ...grpc.CallOption) (*RebootResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RebootResponse)
	err := c.cc.Invoke(ctx, RemoteProvisionService_Reboot_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *remoteProvisionServiceClient) ProbeHTTP(ctx context.Context, in *ProbeHTTPRequest, opts ...grpc.CallOption) (*ProbeHTTPResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ProbeHTTPResponse)
	err := c.cc.Invoke(ctx, RemoteProvisionService_ProbeHTTP_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RemoteProvisionServiceServer is the server API for RemoteProvisionService service.
// All implementations must embed UnimplementedRemoteProvisionServiceServer
// for forward compatibility.
//
// RemoteProvisionService is the gRPC interface to a remote `talosctl
// cluster create` provisioner — the cluster-equivalent of a BuildKit
// remote builder. It is consumed by the `remote` provisioner under
// pkg/provision/providers/remote and served by `talosctl
// remote-provision-launch`.
//
// The server owns the QEMU lifecycle, the state directory, and the bridge
// network. RPC payloads carrying provision.ClusterRequest / provision.Cluster
// are JSON-encoded; the server unmarshals them and hands them to the
// in-process QEMU provisioner unchanged.
type RemoteProvisionServiceServer interface {
	// Ping returns server identity for connectivity sanity checks.
	Ping(context.Context, *emptypb.Empty) (*PingResponse, error)
	// Create provisions a cluster. The stream emits progress events; the
	// terminal event carries the JSON-encoded provision.Cluster.
	Create(*CreateRequest, grpc.ServerStreamingServer[CreateEvent]) error
	// Destroy tears down a previously-created cluster.
	Destroy(context.Context, *DestroyRequest) (*DestroyResponse, error)
	// Reflect returns a previously-created cluster's state by name.
	Reflect(context.Context, *ReflectRequest) (*ReflectResponse, error)
	// StreamLogs tails a machine's QEMU console log from the server's state
	// directory — the remote equivalent of `tail -F <machine>.log`.
	StreamLogs(*LogsRequest, grpc.ServerStreamingServer[LogData]) error
	// StatArtifact reports whether a content-addressed artifact is already
	// cached on the server, so the client can skip re-uploading it.
	StatArtifact(context.Context, *StatArtifactRequest) (*StatArtifactResponse, error)
	// UploadArtifact streams a boot artifact (kernel, initramfs, ISO, ...)
	// to the server's content-addressed cache. The first frame carries the
	// sha256; the rest carry data.
	UploadArtifact(grpc.ClientStreamingServer[ArtifactChunk, ArtifactRef]) error
	// SyncBootArtifacts updates the stable kernel and initramfs references
	// used by an existing no-bootloader cluster.
	SyncBootArtifacts(context.Context, *SyncBootArtifactsRequest) (*SyncBootArtifactsResponse, error)
	// Reboot forcefully restarts one QEMU node.
	Reboot(context.Context, *RebootRequest) (*RebootResponse, error)
	// ProbeHTTP performs a bounded HTTP GET from the provisioner host network namespace.
	ProbeHTTP(context.Context, *ProbeHTTPRequest) (*ProbeHTTPResponse, error)
	mustEmbedUnimplementedRemoteProvisionServiceServer()
}

// UnimplementedRemoteProvisionServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedRemoteProvisionServiceServer struct{}

func (UnimplementedRemoteProvisionServiceServer) Ping(context.Context, *emptypb.Empty) (*PingResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Ping not implemented")
}
func (UnimplementedRemoteProvisionServiceServer) Create(*CreateRequest, grpc.ServerStreamingServer[CreateEvent]) error {
	return status.Error(codes.Unimplemented, "method Create not implemented")
}
func (UnimplementedRemoteProvisionServiceServer) Destroy(context.Context, *DestroyRequest) (*DestroyResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Destroy not implemented")
}
func (UnimplementedRemoteProvisionServiceServer) Reflect(context.Context, *ReflectRequest) (*ReflectResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Reflect not implemented")
}
func (UnimplementedRemoteProvisionServiceServer) StreamLogs(*LogsRequest, grpc.ServerStreamingServer[LogData]) error {
	return status.Error(codes.Unimplemented, "method StreamLogs not implemented")
}
func (UnimplementedRemoteProvisionServiceServer) StatArtifact(context.Context, *StatArtifactRequest) (*StatArtifactResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method StatArtifact not implemented")
}
func (UnimplementedRemoteProvisionServiceServer) UploadArtifact(grpc.ClientStreamingServer[ArtifactChunk, ArtifactRef]) error {
	return status.Error(codes.Unimplemented, "method UploadArtifact not implemented")
}
func (UnimplementedRemoteProvisionServiceServer) SyncBootArtifacts(context.Context, *SyncBootArtifactsRequest) (*SyncBootArtifactsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SyncBootArtifacts not implemented")
}
func (UnimplementedRemoteProvisionServiceServer) Reboot(context.Context, *RebootRequest) (*RebootResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Reboot not implemented")
}
func (UnimplementedRemoteProvisionServiceServer) ProbeHTTP(context.Context, *ProbeHTTPRequest) (*ProbeHTTPResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ProbeHTTP not implemented")
}
func (UnimplementedRemoteProvisionServiceServer) mustEmbedUnimplementedRemoteProvisionServiceServer() {
}
func (UnimplementedRemoteProvisionServiceServer) testEmbeddedByValue() {}

// UnsafeRemoteProvisionServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to RemoteProvisionServiceServer will
// result in compilation errors.
type UnsafeRemoteProvisionServiceServer interface {
	mustEmbedUnimplementedRemoteProvisionServiceServer()
}

func RegisterRemoteProvisionServiceServer(s grpc.ServiceRegistrar, srv RemoteProvisionServiceServer) {
	// If the following call panics, it indicates UnimplementedRemoteProvisionServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&RemoteProvisionService_ServiceDesc, srv)
}

func _RemoteProvisionService_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RemoteProvisionServiceServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RemoteProvisionService_Ping_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RemoteProvisionServiceServer).Ping(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _RemoteProvisionService_Create_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CreateRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RemoteProvisionServiceServer).Create(m, &grpc.GenericServerStream[CreateRequest, CreateEvent]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type RemoteProvisionService_CreateServer = grpc.ServerStreamingServer[CreateEvent]

func _RemoteProvisionService_Destroy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DestroyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RemoteProvisionServiceServer).Destroy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RemoteProvisionService_Destroy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RemoteProvisionServiceServer).Destroy(ctx, req.(*DestroyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RemoteProvisionService_Reflect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReflectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RemoteProvisionServiceServer).Reflect(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RemoteProvisionService_Reflect_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RemoteProvisionServiceServer).Reflect(ctx, req.(*ReflectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RemoteProvisionService_StreamLogs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LogsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RemoteProvisionServiceServer).StreamLogs(m, &grpc.GenericServerStream[LogsRequest, LogData]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type RemoteProvisionService_StreamLogsServer = grpc.ServerStreamingServer[LogData]

func _RemoteProvisionService_StatArtifact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatArtifactRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RemoteProvisionServiceServer).StatArtifact(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RemoteProvisionService_StatArtifact_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RemoteProvisionServiceServer).StatArtifact(ctx, req.(*StatArtifactRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RemoteProvisionService_UploadArtifact_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RemoteProvisionServiceServer).UploadArtifact(&grpc.GenericServerStream[ArtifactChunk, ArtifactRef]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type RemoteProvisionService_UploadArtifactServer = grpc.ClientStreamingServer[ArtifactChunk, ArtifactRef]

func _RemoteProvisionService_SyncBootArtifacts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SyncBootArtifactsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RemoteProvisionServiceServer).SyncBootArtifacts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RemoteProvisionService_SyncBootArtifacts_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RemoteProvisionServiceServer).SyncBootArtifacts(ctx, req.(*SyncBootArtifactsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RemoteProvisionService_Reboot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RebootRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RemoteProvisionServiceServer).Reboot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RemoteProvisionService_Reboot_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RemoteProvisionServiceServer).Reboot(ctx, req.(*RebootRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RemoteProvisionService_ProbeHTTP_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProbeHTTPRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RemoteProvisionServiceServer).ProbeHTTP(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RemoteProvisionService_ProbeHTTP_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RemoteProvisionServiceServer).ProbeHTTP(ctx, req.(*ProbeHTTPRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// RemoteProvisionService_ServiceDesc is the grpc.ServiceDesc for RemoteProvisionService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RemoteProvisionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "remoteprovision.RemoteProvisionService",
	HandlerType: (*RemoteProvisionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _RemoteProvisionService_Ping_Handler,
		},
		{
			MethodName: "Destroy",
			Handler:    _RemoteProvisionService_Destroy_Handler,
		},
		{
			MethodName: "Reflect",
			Handler:    _RemoteProvisionService_Reflect_Handler,
		},
		{
			MethodName: "StatArtifact",
			Handler:    _RemoteProvisionService_StatArtifact_Handler,
		},
		{
			MethodName: "SyncBootArtifacts",
			Handler:    _RemoteProvisionService_SyncBootArtifacts_Handler,
		},
		{
			MethodName: "Reboot",
			Handler:    _RemoteProvisionService_Reboot_Handler,
		},
		{
			MethodName: "ProbeHTTP",
			Handler:    _RemoteProvisionService_ProbeHTTP_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Create",
			Handler:       _RemoteProvisionService_Create_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StreamLogs",
			Handler:       _RemoteProvisionService_StreamLogs_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UploadArtifact",
			Handler:       _RemoteProvisionService_UploadArtifact_Handler,
			ClientStreams: true,
		},
	},
	Metadata: "remoteprovision.proto",
}
