commands.pb.go

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

package commands

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 InitReq struct {
	// Start a Arduino Core Service instance that will provide only Library
	// Manager functionality.
	LibraryManagerOnly   bool     `protobuf:"varint,2,opt,name=library_manager_only,json=libraryManagerOnly,proto3" json:"library_manager_only,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_InitReq proto.InternalMessageInfo

func (m *InitReq) GetLibraryManagerOnly() bool {
	if m != nil {
		return m.LibraryManagerOnly
	}
	return false
}

type InitResp struct {
	// An Arduino Core Service instance.
	Instance *Instance `protobuf:"bytes,1,opt,name=instance,proto3" json:"instance,omitempty"`
	// Error messages related to any problems encountered while parsing the
	// platforms index files.
	PlatformsIndexErrors []string `protobuf:"bytes,2,rep,name=platforms_index_errors,json=platformsIndexErrors,proto3" json:"platforms_index_errors,omitempty"`
	// Error message if a problem was encountered while parsing the libraries
	// index file.
	LibrariesIndexError string `protobuf:"bytes,3,opt,name=libraries_index_error,json=librariesIndexError,proto3" json:"libraries_index_error,omitempty"`
	// Progress of the downloads of platforms and libraries index files.
	DownloadProgress *DownloadProgress `protobuf:"bytes,4,opt,name=download_progress,json=downloadProgress,proto3" json:"download_progress,omitempty"`
	// Describes the current stage of the initialization.
	TaskProgress         *TaskProgress `protobuf:"bytes,5,opt,name=task_progress,json=taskProgress,proto3" json:"task_progress,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_InitResp proto.InternalMessageInfo

func (m *InitResp) GetInstance() *Instance {
	if m != nil {
		return m.Instance
	}
	return nil
}

func (m *InitResp) GetPlatformsIndexErrors() []string {
	if m != nil {
		return m.PlatformsIndexErrors
	}
	return nil
}

func (m *InitResp) GetLibrariesIndexError() string {
	if m != nil {
		return m.LibrariesIndexError
	}
	return ""
}

func (m *InitResp) GetDownloadProgress() *DownloadProgress {
	if m != nil {
		return m.DownloadProgress
	}
	return nil
}

func (m *InitResp) GetTaskProgress() *TaskProgress {
	if m != nil {
		return m.TaskProgress
	}
	return nil
}

type DestroyReq struct {
	// The Arduino Core Service instance to destroy.
	Instance             *Instance `protobuf:"bytes,1,opt,name=instance,proto3" json:"instance,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

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

var xxx_messageInfo_DestroyReq proto.InternalMessageInfo

func (m *DestroyReq) GetInstance() *Instance {
	if m != nil {
		return m.Instance
	}
	return nil
}

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

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

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

var xxx_messageInfo_DestroyResp proto.InternalMessageInfo

type RescanReq struct {
	// Arduino Core Service instance from the Init response.
	Instance             *Instance `protobuf:"bytes,1,opt,name=instance,proto3" json:"instance,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

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

var xxx_messageInfo_RescanReq proto.InternalMessageInfo

func (m *RescanReq) GetInstance() *Instance {
	if m != nil {
		return m.Instance
	}
	return nil
}

type RescanResp struct {
	// Error messages related to any problems encountered while parsing the
	// platforms index file.
	PlatformsIndexErrors []string `protobuf:"bytes,1,rep,name=platforms_index_errors,json=platformsIndexErrors,proto3" json:"platforms_index_errors,omitempty"`
	// Error message if a problem was encountered while parsing the libraries
	// index file.
	LibrariesIndexError  string   `protobuf:"bytes,2,opt,name=libraries_index_error,json=librariesIndexError,proto3" json:"libraries_index_error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RescanResp proto.InternalMessageInfo

func (m *RescanResp) GetPlatformsIndexErrors() []string {
	if m != nil {
		return m.PlatformsIndexErrors
	}
	return nil
}

func (m *RescanResp) GetLibrariesIndexError() string {
	if m != nil {
		return m.LibrariesIndexError
	}
	return ""
}

type UpdateIndexReq struct {
	// Arduino Core Service instance from the Init response.
	Instance             *Instance `protobuf:"bytes,1,opt,name=instance,proto3" json:"instance,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

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

var xxx_messageInfo_UpdateIndexReq proto.InternalMessageInfo

func (m *UpdateIndexReq) GetInstance() *Instance {
	if m != nil {
		return m.Instance
	}
	return nil
}

type UpdateIndexResp struct {
	// Progress of the platforms index download.
	DownloadProgress     *DownloadProgress `protobuf:"bytes,1,opt,name=download_progress,json=downloadProgress,proto3" json:"download_progress,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_UpdateIndexResp proto.InternalMessageInfo

func (m *UpdateIndexResp) GetDownloadProgress() *DownloadProgress {
	if m != nil {
		return m.DownloadProgress
	}
	return nil
}

type UpdateLibrariesIndexReq struct {
	// Arduino Core Service instance from the Init response.
	Instance             *Instance `protobuf:"bytes,1,opt,name=instance,proto3" json:"instance,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *UpdateLibrariesIndexReq) Reset()         { *m = UpdateLibrariesIndexReq{} }
func (m *UpdateLibrariesIndexReq) String() string { return proto.CompactTextString(m) }
func (*UpdateLibrariesIndexReq) ProtoMessage()    {}
func (*UpdateLibrariesIndexReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_3690061a1131852d, []int{8}
}

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

var xxx_messageInfo_UpdateLibrariesIndexReq proto.InternalMessageInfo

func (m *UpdateLibrariesIndexReq) GetInstance() *Instance {
	if m != nil {
		return m.Instance
	}
	return nil
}

type UpdateLibrariesIndexResp struct {
	// Progress of the libraries index download.
	DownloadProgress     *DownloadProgress `protobuf:"bytes,1,opt,name=download_progress,json=downloadProgress,proto3" json:"download_progress,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *UpdateLibrariesIndexResp) Reset()         { *m = UpdateLibrariesIndexResp{} }
func (m *UpdateLibrariesIndexResp) String() string { return proto.CompactTextString(m) }
func (*UpdateLibrariesIndexResp) ProtoMessage()    {}
func (*UpdateLibrariesIndexResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_3690061a1131852d, []int{9}
}

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

var xxx_messageInfo_UpdateLibrariesIndexResp proto.InternalMessageInfo

func (m *UpdateLibrariesIndexResp) GetDownloadProgress() *DownloadProgress {
	if m != nil {
		return m.DownloadProgress
	}
	return nil
}

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

func (m *VersionReq) Reset()         { *m = VersionReq{} }
func (m *VersionReq) String() string { return proto.CompactTextString(m) }
func (*VersionReq) ProtoMessage()    {}
func (*VersionReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_3690061a1131852d, []int{10}
}

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

var xxx_messageInfo_VersionReq proto.InternalMessageInfo

type VersionResp struct {
	// The version of Arduino CLI in use.
	Version              string   `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VersionResp) Reset()         { *m = VersionResp{} }
func (m *VersionResp) String() string { return proto.CompactTextString(m) }
func (*VersionResp) ProtoMessage()    {}
func (*VersionResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_3690061a1131852d, []int{11}
}

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

var xxx_messageInfo_VersionResp proto.InternalMessageInfo

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

func init() {
	proto.RegisterType((*InitReq)(nil), "cc.arduino.cli.commands.InitReq")
	proto.RegisterType((*InitResp)(nil), "cc.arduino.cli.commands.InitResp")
	proto.RegisterType((*DestroyReq)(nil), "cc.arduino.cli.commands.DestroyReq")
	proto.RegisterType((*DestroyResp)(nil), "cc.arduino.cli.commands.DestroyResp")
	proto.RegisterType((*RescanReq)(nil), "cc.arduino.cli.commands.RescanReq")
	proto.RegisterType((*RescanResp)(nil), "cc.arduino.cli.commands.RescanResp")
	proto.RegisterType((*UpdateIndexReq)(nil), "cc.arduino.cli.commands.UpdateIndexReq")
	proto.RegisterType((*UpdateIndexResp)(nil), "cc.arduino.cli.commands.UpdateIndexResp")
	proto.RegisterType((*UpdateLibrariesIndexReq)(nil), "cc.arduino.cli.commands.UpdateLibrariesIndexReq")
	proto.RegisterType((*UpdateLibrariesIndexResp)(nil), "cc.arduino.cli.commands.UpdateLibrariesIndexResp")
	proto.RegisterType((*VersionReq)(nil), "cc.arduino.cli.commands.VersionReq")
	proto.RegisterType((*VersionResp)(nil), "cc.arduino.cli.commands.VersionResp")
}

func init() { proto.RegisterFile("commands/commands.proto", fileDescriptor_3690061a1131852d) }

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

// ArduinoCoreClient is the client API for ArduinoCore service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ArduinoCoreClient interface {
	// Start a new instance of the Arduino Core Service
	Init(ctx context.Context, in *InitReq, opts ...grpc.CallOption) (ArduinoCore_InitClient, error)
	// Destroy an instance of the Arduino Core Service
	Destroy(ctx context.Context, in *DestroyReq, opts ...grpc.CallOption) (*DestroyResp, error)
	// Rescan instance of the Arduino Core Service
	Rescan(ctx context.Context, in *RescanReq, opts ...grpc.CallOption) (*RescanResp, error)
	// Update package index of the Arduino Core Service
	UpdateIndex(ctx context.Context, in *UpdateIndexReq, opts ...grpc.CallOption) (ArduinoCore_UpdateIndexClient, error)
	// Update libraries index
	UpdateLibrariesIndex(ctx context.Context, in *UpdateLibrariesIndexReq, opts ...grpc.CallOption) (ArduinoCore_UpdateLibrariesIndexClient, error)
	// Get the version of Arduino CLI in use.
	Version(ctx context.Context, in *VersionReq, opts ...grpc.CallOption) (*VersionResp, error)
	// Requests details about a board
	BoardDetails(ctx context.Context, in *BoardDetailsReq, opts ...grpc.CallOption) (*BoardDetailsResp, error)
	// Attach a board to a sketch. When the `fqbn` field of a request is not
	// provided, the FQBN of the attached board will be used.
	BoardAttach(ctx context.Context, in *BoardAttachReq, opts ...grpc.CallOption) (ArduinoCore_BoardAttachClient, error)
	// List the boards currently connected to the computer.
	BoardList(ctx context.Context, in *BoardListReq, opts ...grpc.CallOption) (*BoardListResp, error)
	// List all the boards provided by installed platforms.
	BoardListAll(ctx context.Context, in *BoardListAllReq, opts ...grpc.CallOption) (*BoardListAllResp, error)
	// Compile an Arduino sketch.
	Compile(ctx context.Context, in *CompileReq, opts ...grpc.CallOption) (ArduinoCore_CompileClient, error)
	// Download and install a platform and its tool dependencies.
	PlatformInstall(ctx context.Context, in *PlatformInstallReq, opts ...grpc.CallOption) (ArduinoCore_PlatformInstallClient, error)
	// Download a platform and its tool dependencies to the `staging/packages`
	// subdirectory of the data directory.
	PlatformDownload(ctx context.Context, in *PlatformDownloadReq, opts ...grpc.CallOption) (ArduinoCore_PlatformDownloadClient, error)
	// Uninstall a platform as well as its tool dependencies that are not used by
	// other installed platforms.
	PlatformUninstall(ctx context.Context, in *PlatformUninstallReq, opts ...grpc.CallOption) (ArduinoCore_PlatformUninstallClient, error)
	// Upgrade an installed platform to the latest version.
	PlatformUpgrade(ctx context.Context, in *PlatformUpgradeReq, opts ...grpc.CallOption) (ArduinoCore_PlatformUpgradeClient, error)
	// Upload a compiled sketch to an Arduino board.
	Upload(ctx context.Context, in *UploadReq, opts ...grpc.CallOption) (ArduinoCore_UploadClient, error)
	// Search for a platform in the platforms indexes.
	PlatformSearch(ctx context.Context, in *PlatformSearchReq, opts ...grpc.CallOption) (*PlatformSearchResp, error)
	// List all installed platforms.
	PlatformList(ctx context.Context, in *PlatformListReq, opts ...grpc.CallOption) (*PlatformListResp, error)
	// Download the archive file of an Arduino library in the libraries index to
	// the staging directory.
	LibraryDownload(ctx context.Context, in *LibraryDownloadReq, opts ...grpc.CallOption) (ArduinoCore_LibraryDownloadClient, error)
	// Download and install an Arduino library from the libraries index.
	LibraryInstall(ctx context.Context, in *LibraryInstallReq, opts ...grpc.CallOption) (ArduinoCore_LibraryInstallClient, error)
	// Uninstall an Arduino library.
	LibraryUninstall(ctx context.Context, in *LibraryUninstallReq, opts ...grpc.CallOption) (ArduinoCore_LibraryUninstallClient, error)
	// Upgrade all installed Arduino libraries to the newest version available.
	LibraryUpgradeAll(ctx context.Context, in *LibraryUpgradeAllReq, opts ...grpc.CallOption) (ArduinoCore_LibraryUpgradeAllClient, error)
	// List the recursive dependencies of a library, as defined by the `depends`
	// field of the library.properties files.
	LibraryResolveDependencies(ctx context.Context, in *LibraryResolveDependenciesReq, opts ...grpc.CallOption) (*LibraryResolveDependenciesResp, error)
	// Search the Arduino libraries index for libraries.
	LibrarySearch(ctx context.Context, in *LibrarySearchReq, opts ...grpc.CallOption) (*LibrarySearchResp, error)
	// List the installed libraries.
	LibraryList(ctx context.Context, in *LibraryListReq, opts ...grpc.CallOption) (*LibraryListResp, error)
}

type arduinoCoreClient struct {
	cc grpc.ClientConnInterface
}

func NewArduinoCoreClient(cc grpc.ClientConnInterface) ArduinoCoreClient {
	return &arduinoCoreClient{cc}
}

func (c *arduinoCoreClient) Init(ctx context.Context, in *InitReq, opts ...grpc.CallOption) (ArduinoCore_InitClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[0], "/cc.arduino.cli.commands.ArduinoCore/Init", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCoreInitClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_InitClient interface {
	Recv() (*InitResp, error)
	grpc.ClientStream
}

type arduinoCoreInitClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) Destroy(ctx context.Context, in *DestroyReq, opts ...grpc.CallOption) (*DestroyResp, error) {
	out := new(DestroyResp)
	err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/Destroy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *arduinoCoreClient) Rescan(ctx context.Context, in *RescanReq, opts ...grpc.CallOption) (*RescanResp, error) {
	out := new(RescanResp)
	err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/Rescan", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *arduinoCoreClient) UpdateIndex(ctx context.Context, in *UpdateIndexReq, opts ...grpc.CallOption) (ArduinoCore_UpdateIndexClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[1], "/cc.arduino.cli.commands.ArduinoCore/UpdateIndex", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCoreUpdateIndexClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_UpdateIndexClient interface {
	Recv() (*UpdateIndexResp, error)
	grpc.ClientStream
}

type arduinoCoreUpdateIndexClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) UpdateLibrariesIndex(ctx context.Context, in *UpdateLibrariesIndexReq, opts ...grpc.CallOption) (ArduinoCore_UpdateLibrariesIndexClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[2], "/cc.arduino.cli.commands.ArduinoCore/UpdateLibrariesIndex", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCoreUpdateLibrariesIndexClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_UpdateLibrariesIndexClient interface {
	Recv() (*UpdateLibrariesIndexResp, error)
	grpc.ClientStream
}

type arduinoCoreUpdateLibrariesIndexClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) Version(ctx context.Context, in *VersionReq, opts ...grpc.CallOption) (*VersionResp, error) {
	out := new(VersionResp)
	err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/Version", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *arduinoCoreClient) BoardDetails(ctx context.Context, in *BoardDetailsReq, opts ...grpc.CallOption) (*BoardDetailsResp, error) {
	out := new(BoardDetailsResp)
	err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/BoardDetails", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *arduinoCoreClient) BoardAttach(ctx context.Context, in *BoardAttachReq, opts ...grpc.CallOption) (ArduinoCore_BoardAttachClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[3], "/cc.arduino.cli.commands.ArduinoCore/BoardAttach", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCoreBoardAttachClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_BoardAttachClient interface {
	Recv() (*BoardAttachResp, error)
	grpc.ClientStream
}

type arduinoCoreBoardAttachClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) BoardList(ctx context.Context, in *BoardListReq, opts ...grpc.CallOption) (*BoardListResp, error) {
	out := new(BoardListResp)
	err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/BoardList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *arduinoCoreClient) BoardListAll(ctx context.Context, in *BoardListAllReq, opts ...grpc.CallOption) (*BoardListAllResp, error) {
	out := new(BoardListAllResp)
	err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/BoardListAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *arduinoCoreClient) Compile(ctx context.Context, in *CompileReq, opts ...grpc.CallOption) (ArduinoCore_CompileClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[4], "/cc.arduino.cli.commands.ArduinoCore/Compile", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCoreCompileClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_CompileClient interface {
	Recv() (*CompileResp, error)
	grpc.ClientStream
}

type arduinoCoreCompileClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) PlatformInstall(ctx context.Context, in *PlatformInstallReq, opts ...grpc.CallOption) (ArduinoCore_PlatformInstallClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[5], "/cc.arduino.cli.commands.ArduinoCore/PlatformInstall", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCorePlatformInstallClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_PlatformInstallClient interface {
	Recv() (*PlatformInstallResp, error)
	grpc.ClientStream
}

type arduinoCorePlatformInstallClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) PlatformDownload(ctx context.Context, in *PlatformDownloadReq, opts ...grpc.CallOption) (ArduinoCore_PlatformDownloadClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[6], "/cc.arduino.cli.commands.ArduinoCore/PlatformDownload", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCorePlatformDownloadClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_PlatformDownloadClient interface {
	Recv() (*PlatformDownloadResp, error)
	grpc.ClientStream
}

type arduinoCorePlatformDownloadClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) PlatformUninstall(ctx context.Context, in *PlatformUninstallReq, opts ...grpc.CallOption) (ArduinoCore_PlatformUninstallClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[7], "/cc.arduino.cli.commands.ArduinoCore/PlatformUninstall", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCorePlatformUninstallClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_PlatformUninstallClient interface {
	Recv() (*PlatformUninstallResp, error)
	grpc.ClientStream
}

type arduinoCorePlatformUninstallClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) PlatformUpgrade(ctx context.Context, in *PlatformUpgradeReq, opts ...grpc.CallOption) (ArduinoCore_PlatformUpgradeClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[8], "/cc.arduino.cli.commands.ArduinoCore/PlatformUpgrade", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCorePlatformUpgradeClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_PlatformUpgradeClient interface {
	Recv() (*PlatformUpgradeResp, error)
	grpc.ClientStream
}

type arduinoCorePlatformUpgradeClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) Upload(ctx context.Context, in *UploadReq, opts ...grpc.CallOption) (ArduinoCore_UploadClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[9], "/cc.arduino.cli.commands.ArduinoCore/Upload", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCoreUploadClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_UploadClient interface {
	Recv() (*UploadResp, error)
	grpc.ClientStream
}

type arduinoCoreUploadClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) PlatformSearch(ctx context.Context, in *PlatformSearchReq, opts ...grpc.CallOption) (*PlatformSearchResp, error) {
	out := new(PlatformSearchResp)
	err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/PlatformSearch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *arduinoCoreClient) PlatformList(ctx context.Context, in *PlatformListReq, opts ...grpc.CallOption) (*PlatformListResp, error) {
	out := new(PlatformListResp)
	err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/PlatformList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *arduinoCoreClient) LibraryDownload(ctx context.Context, in *LibraryDownloadReq, opts ...grpc.CallOption) (ArduinoCore_LibraryDownloadClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[10], "/cc.arduino.cli.commands.ArduinoCore/LibraryDownload", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCoreLibraryDownloadClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_LibraryDownloadClient interface {
	Recv() (*LibraryDownloadResp, error)
	grpc.ClientStream
}

type arduinoCoreLibraryDownloadClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) LibraryInstall(ctx context.Context, in *LibraryInstallReq, opts ...grpc.CallOption) (ArduinoCore_LibraryInstallClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[11], "/cc.arduino.cli.commands.ArduinoCore/LibraryInstall", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCoreLibraryInstallClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_LibraryInstallClient interface {
	Recv() (*LibraryInstallResp, error)
	grpc.ClientStream
}

type arduinoCoreLibraryInstallClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) LibraryUninstall(ctx context.Context, in *LibraryUninstallReq, opts ...grpc.CallOption) (ArduinoCore_LibraryUninstallClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[12], "/cc.arduino.cli.commands.ArduinoCore/LibraryUninstall", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCoreLibraryUninstallClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_LibraryUninstallClient interface {
	Recv() (*LibraryUninstallResp, error)
	grpc.ClientStream
}

type arduinoCoreLibraryUninstallClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) LibraryUpgradeAll(ctx context.Context, in *LibraryUpgradeAllReq, opts ...grpc.CallOption) (ArduinoCore_LibraryUpgradeAllClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[13], "/cc.arduino.cli.commands.ArduinoCore/LibraryUpgradeAll", opts...)
	if err != nil {
		return nil, err
	}
	x := &arduinoCoreLibraryUpgradeAllClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ArduinoCore_LibraryUpgradeAllClient interface {
	Recv() (*LibraryUpgradeAllResp, error)
	grpc.ClientStream
}

type arduinoCoreLibraryUpgradeAllClient struct {
	grpc.ClientStream
}

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

func (c *arduinoCoreClient) LibraryResolveDependencies(ctx context.Context, in *LibraryResolveDependenciesReq, opts ...grpc.CallOption) (*LibraryResolveDependenciesResp, error) {
	out := new(LibraryResolveDependenciesResp)
	err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/LibraryResolveDependencies", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *arduinoCoreClient) LibrarySearch(ctx context.Context, in *LibrarySearchReq, opts ...grpc.CallOption) (*LibrarySearchResp, error) {
	out := new(LibrarySearchResp)
	err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/LibrarySearch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *arduinoCoreClient) LibraryList(ctx context.Context, in *LibraryListReq, opts ...grpc.CallOption) (*LibraryListResp, error) {
	out := new(LibraryListResp)
	err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/LibraryList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ArduinoCoreServer is the server API for ArduinoCore service.
type ArduinoCoreServer interface {
	// Start a new instance of the Arduino Core Service
	Init(*InitReq, ArduinoCore_InitServer) error
	// Destroy an instance of the Arduino Core Service
	Destroy(context.Context, *DestroyReq) (*DestroyResp, error)
	// Rescan instance of the Arduino Core Service
	Rescan(context.Context, *RescanReq) (*RescanResp, error)
	// Update package index of the Arduino Core Service
	UpdateIndex(*UpdateIndexReq, ArduinoCore_UpdateIndexServer) error
	// Update libraries index
	UpdateLibrariesIndex(*UpdateLibrariesIndexReq, ArduinoCore_UpdateLibrariesIndexServer) error
	// Get the version of Arduino CLI in use.
	Version(context.Context, *VersionReq) (*VersionResp, error)
	// Requests details about a board
	BoardDetails(context.Context, *BoardDetailsReq) (*BoardDetailsResp, error)
	// Attach a board to a sketch. When the `fqbn` field of a request is not
	// provided, the FQBN of the attached board will be used.
	BoardAttach(*BoardAttachReq, ArduinoCore_BoardAttachServer) error
	// List the boards currently connected to the computer.
	BoardList(context.Context, *BoardListReq) (*BoardListResp, error)
	// List all the boards provided by installed platforms.
	BoardListAll(context.Context, *BoardListAllReq) (*BoardListAllResp, error)
	// Compile an Arduino sketch.
	Compile(*CompileReq, ArduinoCore_CompileServer) error
	// Download and install a platform and its tool dependencies.
	PlatformInstall(*PlatformInstallReq, ArduinoCore_PlatformInstallServer) error
	// Download a platform and its tool dependencies to the `staging/packages`
	// subdirectory of the data directory.
	PlatformDownload(*PlatformDownloadReq, ArduinoCore_PlatformDownloadServer) error
	// Uninstall a platform as well as its tool dependencies that are not used by
	// other installed platforms.
	PlatformUninstall(*PlatformUninstallReq, ArduinoCore_PlatformUninstallServer) error
	// Upgrade an installed platform to the latest version.
	PlatformUpgrade(*PlatformUpgradeReq, ArduinoCore_PlatformUpgradeServer) error
	// Upload a compiled sketch to an Arduino board.
	Upload(*UploadReq, ArduinoCore_UploadServer) error
	// Search for a platform in the platforms indexes.
	PlatformSearch(context.Context, *PlatformSearchReq) (*PlatformSearchResp, error)
	// List all installed platforms.
	PlatformList(context.Context, *PlatformListReq) (*PlatformListResp, error)
	// Download the archive file of an Arduino library in the libraries index to
	// the staging directory.
	LibraryDownload(*LibraryDownloadReq, ArduinoCore_LibraryDownloadServer) error
	// Download and install an Arduino library from the libraries index.
	LibraryInstall(*LibraryInstallReq, ArduinoCore_LibraryInstallServer) error
	// Uninstall an Arduino library.
	LibraryUninstall(*LibraryUninstallReq, ArduinoCore_LibraryUninstallServer) error
	// Upgrade all installed Arduino libraries to the newest version available.
	LibraryUpgradeAll(*LibraryUpgradeAllReq, ArduinoCore_LibraryUpgradeAllServer) error
	// List the recursive dependencies of a library, as defined by the `depends`
	// field of the library.properties files.
	LibraryResolveDependencies(context.Context, *LibraryResolveDependenciesReq) (*LibraryResolveDependenciesResp, error)
	// Search the Arduino libraries index for libraries.
	LibrarySearch(context.Context, *LibrarySearchReq) (*LibrarySearchResp, error)
	// List the installed libraries.
	LibraryList(context.Context, *LibraryListReq) (*LibraryListResp, error)
}

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

func (*UnimplementedArduinoCoreServer) Init(req *InitReq, srv ArduinoCore_InitServer) error {
	return status.Errorf(codes.Unimplemented, "method Init not implemented")
}
func (*UnimplementedArduinoCoreServer) Destroy(ctx context.Context, req *DestroyReq) (*DestroyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Destroy not implemented")
}
func (*UnimplementedArduinoCoreServer) Rescan(ctx context.Context, req *RescanReq) (*RescanResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Rescan not implemented")
}
func (*UnimplementedArduinoCoreServer) UpdateIndex(req *UpdateIndexReq, srv ArduinoCore_UpdateIndexServer) error {
	return status.Errorf(codes.Unimplemented, "method UpdateIndex not implemented")
}
func (*UnimplementedArduinoCoreServer) UpdateLibrariesIndex(req *UpdateLibrariesIndexReq, srv ArduinoCore_UpdateLibrariesIndexServer) error {
	return status.Errorf(codes.Unimplemented, "method UpdateLibrariesIndex not implemented")
}
func (*UnimplementedArduinoCoreServer) Version(ctx context.Context, req *VersionReq) (*VersionResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Version not implemented")
}
func (*UnimplementedArduinoCoreServer) BoardDetails(ctx context.Context, req *BoardDetailsReq) (*BoardDetailsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BoardDetails not implemented")
}
func (*UnimplementedArduinoCoreServer) BoardAttach(req *BoardAttachReq, srv ArduinoCore_BoardAttachServer) error {
	return status.Errorf(codes.Unimplemented, "method BoardAttach not implemented")
}
func (*UnimplementedArduinoCoreServer) BoardList(ctx context.Context, req *BoardListReq) (*BoardListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BoardList not implemented")
}
func (*UnimplementedArduinoCoreServer) BoardListAll(ctx context.Context, req *BoardListAllReq) (*BoardListAllResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BoardListAll not implemented")
}
func (*UnimplementedArduinoCoreServer) Compile(req *CompileReq, srv ArduinoCore_CompileServer) error {
	return status.Errorf(codes.Unimplemented, "method Compile not implemented")
}
func (*UnimplementedArduinoCoreServer) PlatformInstall(req *PlatformInstallReq, srv ArduinoCore_PlatformInstallServer) error {
	return status.Errorf(codes.Unimplemented, "method PlatformInstall not implemented")
}
func (*UnimplementedArduinoCoreServer) PlatformDownload(req *PlatformDownloadReq, srv ArduinoCore_PlatformDownloadServer) error {
	return status.Errorf(codes.Unimplemented, "method PlatformDownload not implemented")
}
func (*UnimplementedArduinoCoreServer) PlatformUninstall(req *PlatformUninstallReq, srv ArduinoCore_PlatformUninstallServer) error {
	return status.Errorf(codes.Unimplemented, "method PlatformUninstall not implemented")
}
func (*UnimplementedArduinoCoreServer) PlatformUpgrade(req *PlatformUpgradeReq, srv ArduinoCore_PlatformUpgradeServer) error {
	return status.Errorf(codes.Unimplemented, "method PlatformUpgrade not implemented")
}
func (*UnimplementedArduinoCoreServer) Upload(req *UploadReq, srv ArduinoCore_UploadServer) error {
	return status.Errorf(codes.Unimplemented, "method Upload not implemented")
}
func (*UnimplementedArduinoCoreServer) PlatformSearch(ctx context.Context, req *PlatformSearchReq) (*PlatformSearchResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PlatformSearch not implemented")
}
func (*UnimplementedArduinoCoreServer) PlatformList(ctx context.Context, req *PlatformListReq) (*PlatformListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PlatformList not implemented")
}
func (*UnimplementedArduinoCoreServer) LibraryDownload(req *LibraryDownloadReq, srv ArduinoCore_LibraryDownloadServer) error {
	return status.Errorf(codes.Unimplemented, "method LibraryDownload not implemented")
}
func (*UnimplementedArduinoCoreServer) LibraryInstall(req *LibraryInstallReq, srv ArduinoCore_LibraryInstallServer) error {
	return status.Errorf(codes.Unimplemented, "method LibraryInstall not implemented")
}
func (*UnimplementedArduinoCoreServer) LibraryUninstall(req *LibraryUninstallReq, srv ArduinoCore_LibraryUninstallServer) error {
	return status.Errorf(codes.Unimplemented, "method LibraryUninstall not implemented")
}
func (*UnimplementedArduinoCoreServer) LibraryUpgradeAll(req *LibraryUpgradeAllReq, srv ArduinoCore_LibraryUpgradeAllServer) error {
	return status.Errorf(codes.Unimplemented, "method LibraryUpgradeAll not implemented")
}
func (*UnimplementedArduinoCoreServer) LibraryResolveDependencies(ctx context.Context, req *LibraryResolveDependenciesReq) (*LibraryResolveDependenciesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LibraryResolveDependencies not implemented")
}
func (*UnimplementedArduinoCoreServer) LibrarySearch(ctx context.Context, req *LibrarySearchReq) (*LibrarySearchResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LibrarySearch not implemented")
}
func (*UnimplementedArduinoCoreServer) LibraryList(ctx context.Context, req *LibraryListReq) (*LibraryListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LibraryList not implemented")
}

func RegisterArduinoCoreServer(s *grpc.Server, srv ArduinoCoreServer) {
	s.RegisterService(&_ArduinoCore_serviceDesc, srv)
}

func _ArduinoCore_Init_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InitReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).Init(m, &arduinoCoreInitServer{stream})
}

type ArduinoCore_InitServer interface {
	Send(*InitResp) error
	grpc.ServerStream
}

type arduinoCoreInitServer struct {
	grpc.ServerStream
}

func (x *arduinoCoreInitServer) Send(m *InitResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_Destroy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DestroyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ArduinoCoreServer).Destroy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cc.arduino.cli.commands.ArduinoCore/Destroy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ArduinoCoreServer).Destroy(ctx, req.(*DestroyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ArduinoCore_Rescan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RescanReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ArduinoCoreServer).Rescan(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cc.arduino.cli.commands.ArduinoCore/Rescan",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ArduinoCoreServer).Rescan(ctx, req.(*RescanReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ArduinoCore_UpdateIndex_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(UpdateIndexReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).UpdateIndex(m, &arduinoCoreUpdateIndexServer{stream})
}

type ArduinoCore_UpdateIndexServer interface {
	Send(*UpdateIndexResp) error
	grpc.ServerStream
}

type arduinoCoreUpdateIndexServer struct {
	grpc.ServerStream
}

func (x *arduinoCoreUpdateIndexServer) Send(m *UpdateIndexResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_UpdateLibrariesIndex_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(UpdateLibrariesIndexReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).UpdateLibrariesIndex(m, &arduinoCoreUpdateLibrariesIndexServer{stream})
}

type ArduinoCore_UpdateLibrariesIndexServer interface {
	Send(*UpdateLibrariesIndexResp) error
	grpc.ServerStream
}

type arduinoCoreUpdateLibrariesIndexServer struct {
	grpc.ServerStream
}

func (x *arduinoCoreUpdateLibrariesIndexServer) Send(m *UpdateLibrariesIndexResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_Version_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VersionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ArduinoCoreServer).Version(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cc.arduino.cli.commands.ArduinoCore/Version",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ArduinoCoreServer).Version(ctx, req.(*VersionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ArduinoCore_BoardDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BoardDetailsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ArduinoCoreServer).BoardDetails(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cc.arduino.cli.commands.ArduinoCore/BoardDetails",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ArduinoCoreServer).BoardDetails(ctx, req.(*BoardDetailsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ArduinoCore_BoardAttach_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(BoardAttachReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).BoardAttach(m, &arduinoCoreBoardAttachServer{stream})
}

type ArduinoCore_BoardAttachServer interface {
	Send(*BoardAttachResp) error
	grpc.ServerStream
}

type arduinoCoreBoardAttachServer struct {
	grpc.ServerStream
}

func (x *arduinoCoreBoardAttachServer) Send(m *BoardAttachResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_BoardList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BoardListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ArduinoCoreServer).BoardList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cc.arduino.cli.commands.ArduinoCore/BoardList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ArduinoCoreServer).BoardList(ctx, req.(*BoardListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ArduinoCore_BoardListAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BoardListAllReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ArduinoCoreServer).BoardListAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cc.arduino.cli.commands.ArduinoCore/BoardListAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ArduinoCoreServer).BoardListAll(ctx, req.(*BoardListAllReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ArduinoCore_Compile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CompileReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).Compile(m, &arduinoCoreCompileServer{stream})
}

type ArduinoCore_CompileServer interface {
	Send(*CompileResp) error
	grpc.ServerStream
}

type arduinoCoreCompileServer struct {
	grpc.ServerStream
}

func (x *arduinoCoreCompileServer) Send(m *CompileResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_PlatformInstall_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PlatformInstallReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).PlatformInstall(m, &arduinoCorePlatformInstallServer{stream})
}

type ArduinoCore_PlatformInstallServer interface {
	Send(*PlatformInstallResp) error
	grpc.ServerStream
}

type arduinoCorePlatformInstallServer struct {
	grpc.ServerStream
}

func (x *arduinoCorePlatformInstallServer) Send(m *PlatformInstallResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_PlatformDownload_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PlatformDownloadReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).PlatformDownload(m, &arduinoCorePlatformDownloadServer{stream})
}

type ArduinoCore_PlatformDownloadServer interface {
	Send(*PlatformDownloadResp) error
	grpc.ServerStream
}

type arduinoCorePlatformDownloadServer struct {
	grpc.ServerStream
}

func (x *arduinoCorePlatformDownloadServer) Send(m *PlatformDownloadResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_PlatformUninstall_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PlatformUninstallReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).PlatformUninstall(m, &arduinoCorePlatformUninstallServer{stream})
}

type ArduinoCore_PlatformUninstallServer interface {
	Send(*PlatformUninstallResp) error
	grpc.ServerStream
}

type arduinoCorePlatformUninstallServer struct {
	grpc.ServerStream
}

func (x *arduinoCorePlatformUninstallServer) Send(m *PlatformUninstallResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_PlatformUpgrade_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PlatformUpgradeReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).PlatformUpgrade(m, &arduinoCorePlatformUpgradeServer{stream})
}

type ArduinoCore_PlatformUpgradeServer interface {
	Send(*PlatformUpgradeResp) error
	grpc.ServerStream
}

type arduinoCorePlatformUpgradeServer struct {
	grpc.ServerStream
}

func (x *arduinoCorePlatformUpgradeServer) Send(m *PlatformUpgradeResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_Upload_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(UploadReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).Upload(m, &arduinoCoreUploadServer{stream})
}

type ArduinoCore_UploadServer interface {
	Send(*UploadResp) error
	grpc.ServerStream
}

type arduinoCoreUploadServer struct {
	grpc.ServerStream
}

func (x *arduinoCoreUploadServer) Send(m *UploadResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_PlatformSearch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PlatformSearchReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ArduinoCoreServer).PlatformSearch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cc.arduino.cli.commands.ArduinoCore/PlatformSearch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ArduinoCoreServer).PlatformSearch(ctx, req.(*PlatformSearchReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ArduinoCore_PlatformList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PlatformListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ArduinoCoreServer).PlatformList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cc.arduino.cli.commands.ArduinoCore/PlatformList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ArduinoCoreServer).PlatformList(ctx, req.(*PlatformListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ArduinoCore_LibraryDownload_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LibraryDownloadReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).LibraryDownload(m, &arduinoCoreLibraryDownloadServer{stream})
}

type ArduinoCore_LibraryDownloadServer interface {
	Send(*LibraryDownloadResp) error
	grpc.ServerStream
}

type arduinoCoreLibraryDownloadServer struct {
	grpc.ServerStream
}

func (x *arduinoCoreLibraryDownloadServer) Send(m *LibraryDownloadResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_LibraryInstall_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LibraryInstallReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).LibraryInstall(m, &arduinoCoreLibraryInstallServer{stream})
}

type ArduinoCore_LibraryInstallServer interface {
	Send(*LibraryInstallResp) error
	grpc.ServerStream
}

type arduinoCoreLibraryInstallServer struct {
	grpc.ServerStream
}

func (x *arduinoCoreLibraryInstallServer) Send(m *LibraryInstallResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_LibraryUninstall_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LibraryUninstallReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).LibraryUninstall(m, &arduinoCoreLibraryUninstallServer{stream})
}

type ArduinoCore_LibraryUninstallServer interface {
	Send(*LibraryUninstallResp) error
	grpc.ServerStream
}

type arduinoCoreLibraryUninstallServer struct {
	grpc.ServerStream
}

func (x *arduinoCoreLibraryUninstallServer) Send(m *LibraryUninstallResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_LibraryUpgradeAll_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LibraryUpgradeAllReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ArduinoCoreServer).LibraryUpgradeAll(m, &arduinoCoreLibraryUpgradeAllServer{stream})
}

type ArduinoCore_LibraryUpgradeAllServer interface {
	Send(*LibraryUpgradeAllResp) error
	grpc.ServerStream
}

type arduinoCoreLibraryUpgradeAllServer struct {
	grpc.ServerStream
}

func (x *arduinoCoreLibraryUpgradeAllServer) Send(m *LibraryUpgradeAllResp) error {
	return x.ServerStream.SendMsg(m)
}

func _ArduinoCore_LibraryResolveDependencies_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LibraryResolveDependenciesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ArduinoCoreServer).LibraryResolveDependencies(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cc.arduino.cli.commands.ArduinoCore/LibraryResolveDependencies",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ArduinoCoreServer).LibraryResolveDependencies(ctx, req.(*LibraryResolveDependenciesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ArduinoCore_LibrarySearch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LibrarySearchReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ArduinoCoreServer).LibrarySearch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cc.arduino.cli.commands.ArduinoCore/LibrarySearch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ArduinoCoreServer).LibrarySearch(ctx, req.(*LibrarySearchReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ArduinoCore_LibraryList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LibraryListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ArduinoCoreServer).LibraryList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cc.arduino.cli.commands.ArduinoCore/LibraryList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ArduinoCoreServer).LibraryList(ctx, req.(*LibraryListReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _ArduinoCore_serviceDesc = grpc.ServiceDesc{
	ServiceName: "cc.arduino.cli.commands.ArduinoCore",
	HandlerType: (*ArduinoCoreServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Destroy",
			Handler:    _ArduinoCore_Destroy_Handler,
		},
		{
			MethodName: "Rescan",
			Handler:    _ArduinoCore_Rescan_Handler,
		},
		{
			MethodName: "Version",
			Handler:    _ArduinoCore_Version_Handler,
		},
		{
			MethodName: "BoardDetails",
			Handler:    _ArduinoCore_BoardDetails_Handler,
		},
		{
			MethodName: "BoardList",
			Handler:    _ArduinoCore_BoardList_Handler,
		},
		{
			MethodName: "BoardListAll",
			Handler:    _ArduinoCore_BoardListAll_Handler,
		},
		{
			MethodName: "PlatformSearch",
			Handler:    _ArduinoCore_PlatformSearch_Handler,
		},
		{
			MethodName: "PlatformList",
			Handler:    _ArduinoCore_PlatformList_Handler,
		},
		{
			MethodName: "LibraryResolveDependencies",
			Handler:    _ArduinoCore_LibraryResolveDependencies_Handler,
		},
		{
			MethodName: "LibrarySearch",
			Handler:    _ArduinoCore_LibrarySearch_Handler,
		},
		{
			MethodName: "LibraryList",
			Handler:    _ArduinoCore_LibraryList_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Init",
			Handler:       _ArduinoCore_Init_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UpdateIndex",
			Handler:       _ArduinoCore_UpdateIndex_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UpdateLibrariesIndex",
			Handler:       _ArduinoCore_UpdateLibrariesIndex_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "BoardAttach",
			Handler:       _ArduinoCore_BoardAttach_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Compile",
			Handler:       _ArduinoCore_Compile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "PlatformInstall",
			Handler:       _ArduinoCore_PlatformInstall_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "PlatformDownload",
			Handler:       _ArduinoCore_PlatformDownload_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "PlatformUninstall",
			Handler:       _ArduinoCore_PlatformUninstall_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "PlatformUpgrade",
			Handler:       _ArduinoCore_PlatformUpgrade_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Upload",
			Handler:       _ArduinoCore_Upload_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "LibraryDownload",
			Handler:       _ArduinoCore_LibraryDownload_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "LibraryInstall",
			Handler:       _ArduinoCore_LibraryInstall_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "LibraryUninstall",
			Handler:       _ArduinoCore_LibraryUninstall_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "LibraryUpgradeAll",
			Handler:       _ArduinoCore_LibraryUpgradeAll_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "commands/commands.proto",
}