// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: diskspace.proto

package multinodepb

import (
	context "context"
	fmt "fmt"
	math "math"
	time "time"

	proto "github.com/gogo/protobuf/proto"

	drpc "storj.io/drpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

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

func (m *GetDiskSpaceRequest) Reset()         { *m = GetDiskSpaceRequest{} }
func (m *GetDiskSpaceRequest) String() string { return proto.CompactTextString(m) }
func (*GetDiskSpaceRequest) ProtoMessage()    {}
func (*GetDiskSpaceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9d1904cedee84a32, []int{0}
}
func (m *GetDiskSpaceRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetDiskSpaceRequest.Unmarshal(m, b)
}
func (m *GetDiskSpaceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetDiskSpaceRequest.Marshal(b, m, deterministic)
}
func (m *GetDiskSpaceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetDiskSpaceRequest.Merge(m, src)
}
func (m *GetDiskSpaceRequest) XXX_Size() int {
	return xxx_messageInfo_GetDiskSpaceRequest.Size(m)
}
func (m *GetDiskSpaceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetDiskSpaceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetDiskSpaceRequest proto.InternalMessageInfo

type GetDiskSpaceResponse struct {
	DiskSpace            *DiskSpace `protobuf:"bytes,1,opt,name=disk_space,json=diskSpace,proto3" json:"disk_space,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *GetDiskSpaceResponse) Reset()         { *m = GetDiskSpaceResponse{} }
func (m *GetDiskSpaceResponse) String() string { return proto.CompactTextString(m) }
func (*GetDiskSpaceResponse) ProtoMessage()    {}
func (*GetDiskSpaceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9d1904cedee84a32, []int{1}
}
func (m *GetDiskSpaceResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetDiskSpaceResponse.Unmarshal(m, b)
}
func (m *GetDiskSpaceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetDiskSpaceResponse.Marshal(b, m, deterministic)
}
func (m *GetDiskSpaceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetDiskSpaceResponse.Merge(m, src)
}
func (m *GetDiskSpaceResponse) XXX_Size() int {
	return xxx_messageInfo_GetDiskSpaceResponse.Size(m)
}
func (m *GetDiskSpaceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetDiskSpaceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetDiskSpaceResponse proto.InternalMessageInfo

func (m *GetDiskSpaceResponse) GetDiskSpace() *DiskSpace {
	if m != nil {
		return m.DiskSpace
	}
	return nil
}

// DiskSpace stores all info about storagenode disk space.
type DiskSpace struct {
	Used                 int64    `protobuf:"varint,1,opt,name=used,proto3" json:"used,omitempty"`
	Available            int64    `protobuf:"varint,2,opt,name=available,proto3" json:"available,omitempty"`
	Trash                int64    `protobuf:"varint,3,opt,name=trash,proto3" json:"trash,omitempty"`
	Overused             int64    `protobuf:"varint,4,opt,name=overused,proto3" json:"overused,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DiskSpace) Reset()         { *m = DiskSpace{} }
func (m *DiskSpace) String() string { return proto.CompactTextString(m) }
func (*DiskSpace) ProtoMessage()    {}
func (*DiskSpace) Descriptor() ([]byte, []int) {
	return fileDescriptor_9d1904cedee84a32, []int{2}
}
func (m *DiskSpace) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DiskSpace.Unmarshal(m, b)
}
func (m *DiskSpace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DiskSpace.Marshal(b, m, deterministic)
}
func (m *DiskSpace) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DiskSpace.Merge(m, src)
}
func (m *DiskSpace) XXX_Size() int {
	return xxx_messageInfo_DiskSpace.Size(m)
}
func (m *DiskSpace) XXX_DiscardUnknown() {
	xxx_messageInfo_DiskSpace.DiscardUnknown(m)
}

var xxx_messageInfo_DiskSpace proto.InternalMessageInfo

func (m *DiskSpace) GetUsed() int64 {
	if m != nil {
		return m.Used
	}
	return 0
}

func (m *DiskSpace) GetAvailable() int64 {
	if m != nil {
		return m.Available
	}
	return 0
}

func (m *DiskSpace) GetTrash() int64 {
	if m != nil {
		return m.Trash
	}
	return 0
}

func (m *DiskSpace) GetOverused() int64 {
	if m != nil {
		return m.Overused
	}
	return 0
}

type DailyStorageUsageRequest struct {
	From                 time.Time `protobuf:"bytes,1,opt,name=from,proto3,stdtime" json:"from"`
	To                   time.Time `protobuf:"bytes,2,opt,name=to,proto3,stdtime" json:"to"`
	SatelliteId          NodeID    `protobuf:"bytes,3,opt,name=satellite_id,json=satelliteId,proto3,customtype=NodeID" json:"satellite_id"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *DailyStorageUsageRequest) Reset()         { *m = DailyStorageUsageRequest{} }
func (m *DailyStorageUsageRequest) String() string { return proto.CompactTextString(m) }
func (*DailyStorageUsageRequest) ProtoMessage()    {}
func (*DailyStorageUsageRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9d1904cedee84a32, []int{3}
}
func (m *DailyStorageUsageRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DailyStorageUsageRequest.Unmarshal(m, b)
}
func (m *DailyStorageUsageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DailyStorageUsageRequest.Marshal(b, m, deterministic)
}
func (m *DailyStorageUsageRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DailyStorageUsageRequest.Merge(m, src)
}
func (m *DailyStorageUsageRequest) XXX_Size() int {
	return xxx_messageInfo_DailyStorageUsageRequest.Size(m)
}
func (m *DailyStorageUsageRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DailyStorageUsageRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DailyStorageUsageRequest proto.InternalMessageInfo

func (m *DailyStorageUsageRequest) GetFrom() time.Time {
	if m != nil {
		return m.From
	}
	return time.Time{}
}

func (m *DailyStorageUsageRequest) GetTo() time.Time {
	if m != nil {
		return m.To
	}
	return time.Time{}
}

type DailyStorageUsageResponse struct {
	NodeId               []byte                                    `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	DailyStorageUsage    []*DailyStorageUsageResponse_StorageUsage `protobuf:"bytes,2,rep,name=daily_storage_usage,json=dailyStorageUsage,proto3" json:"daily_storage_usage,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                  `json:"-"`
	XXX_unrecognized     []byte                                    `json:"-"`
	XXX_sizecache        int32                                     `json:"-"`
}

func (m *DailyStorageUsageResponse) Reset()         { *m = DailyStorageUsageResponse{} }
func (m *DailyStorageUsageResponse) String() string { return proto.CompactTextString(m) }
func (*DailyStorageUsageResponse) ProtoMessage()    {}
func (*DailyStorageUsageResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9d1904cedee84a32, []int{4}
}
func (m *DailyStorageUsageResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DailyStorageUsageResponse.Unmarshal(m, b)
}
func (m *DailyStorageUsageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DailyStorageUsageResponse.Marshal(b, m, deterministic)
}
func (m *DailyStorageUsageResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DailyStorageUsageResponse.Merge(m, src)
}
func (m *DailyStorageUsageResponse) XXX_Size() int {
	return xxx_messageInfo_DailyStorageUsageResponse.Size(m)
}
func (m *DailyStorageUsageResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DailyStorageUsageResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DailyStorageUsageResponse proto.InternalMessageInfo

func (m *DailyStorageUsageResponse) GetNodeId() []byte {
	if m != nil {
		return m.NodeId
	}
	return nil
}

func (m *DailyStorageUsageResponse) GetDailyStorageUsage() []*DailyStorageUsageResponse_StorageUsage {
	if m != nil {
		return m.DailyStorageUsage
	}
	return nil
}

type DailyStorageUsageResponse_StorageUsage struct {
	AtRestTotal          float64   `protobuf:"fixed64,1,opt,name=at_rest_total,json=atRestTotal,proto3" json:"at_rest_total,omitempty"`
	Timestamp            time.Time `protobuf:"bytes,2,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *DailyStorageUsageResponse_StorageUsage) Reset() {
	*m = DailyStorageUsageResponse_StorageUsage{}
}
func (m *DailyStorageUsageResponse_StorageUsage) String() string { return proto.CompactTextString(m) }
func (*DailyStorageUsageResponse_StorageUsage) ProtoMessage()    {}
func (*DailyStorageUsageResponse_StorageUsage) Descriptor() ([]byte, []int) {
	return fileDescriptor_9d1904cedee84a32, []int{4, 0}
}
func (m *DailyStorageUsageResponse_StorageUsage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DailyStorageUsageResponse_StorageUsage.Unmarshal(m, b)
}
func (m *DailyStorageUsageResponse_StorageUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DailyStorageUsageResponse_StorageUsage.Marshal(b, m, deterministic)
}
func (m *DailyStorageUsageResponse_StorageUsage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DailyStorageUsageResponse_StorageUsage.Merge(m, src)
}
func (m *DailyStorageUsageResponse_StorageUsage) XXX_Size() int {
	return xxx_messageInfo_DailyStorageUsageResponse_StorageUsage.Size(m)
}
func (m *DailyStorageUsageResponse_StorageUsage) XXX_DiscardUnknown() {
	xxx_messageInfo_DailyStorageUsageResponse_StorageUsage.DiscardUnknown(m)
}

var xxx_messageInfo_DailyStorageUsageResponse_StorageUsage proto.InternalMessageInfo

func (m *DailyStorageUsageResponse_StorageUsage) GetAtRestTotal() float64 {
	if m != nil {
		return m.AtRestTotal
	}
	return 0
}

func (m *DailyStorageUsageResponse_StorageUsage) GetTimestamp() time.Time {
	if m != nil {
		return m.Timestamp
	}
	return time.Time{}
}

type SatelliteSummaryRequest struct {
	From                 time.Time `protobuf:"bytes,1,opt,name=from,proto3,stdtime" json:"from"`
	To                   time.Time `protobuf:"bytes,2,opt,name=to,proto3,stdtime" json:"to"`
	SatelliteId          NodeID    `protobuf:"bytes,3,opt,name=satellite_id,json=satelliteId,proto3,customtype=NodeID" json:"satellite_id"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *SatelliteSummaryRequest) Reset()         { *m = SatelliteSummaryRequest{} }
func (m *SatelliteSummaryRequest) String() string { return proto.CompactTextString(m) }
func (*SatelliteSummaryRequest) ProtoMessage()    {}
func (*SatelliteSummaryRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9d1904cedee84a32, []int{5}
}
func (m *SatelliteSummaryRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SatelliteSummaryRequest.Unmarshal(m, b)
}
func (m *SatelliteSummaryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SatelliteSummaryRequest.Marshal(b, m, deterministic)
}
func (m *SatelliteSummaryRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SatelliteSummaryRequest.Merge(m, src)
}
func (m *SatelliteSummaryRequest) XXX_Size() int {
	return xxx_messageInfo_SatelliteSummaryRequest.Size(m)
}
func (m *SatelliteSummaryRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SatelliteSummaryRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SatelliteSummaryRequest proto.InternalMessageInfo

func (m *SatelliteSummaryRequest) GetFrom() time.Time {
	if m != nil {
		return m.From
	}
	return time.Time{}
}

func (m *SatelliteSummaryRequest) GetTo() time.Time {
	if m != nil {
		return m.To
	}
	return time.Time{}
}

type SatelliteSummaryResponse struct {
	StorageUsage         float64  `protobuf:"fixed64,1,opt,name=storage_usage,json=storageUsage,proto3" json:"storage_usage,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SatelliteSummaryResponse) Reset()         { *m = SatelliteSummaryResponse{} }
func (m *SatelliteSummaryResponse) String() string { return proto.CompactTextString(m) }
func (*SatelliteSummaryResponse) ProtoMessage()    {}
func (*SatelliteSummaryResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9d1904cedee84a32, []int{6}
}
func (m *SatelliteSummaryResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SatelliteSummaryResponse.Unmarshal(m, b)
}
func (m *SatelliteSummaryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SatelliteSummaryResponse.Marshal(b, m, deterministic)
}
func (m *SatelliteSummaryResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SatelliteSummaryResponse.Merge(m, src)
}
func (m *SatelliteSummaryResponse) XXX_Size() int {
	return xxx_messageInfo_SatelliteSummaryResponse.Size(m)
}
func (m *SatelliteSummaryResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SatelliteSummaryResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SatelliteSummaryResponse proto.InternalMessageInfo

func (m *SatelliteSummaryResponse) GetStorageUsage() float64 {
	if m != nil {
		return m.StorageUsage
	}
	return 0
}

func init() {
	proto.RegisterType((*GetDiskSpaceRequest)(nil), "diskspace.GetDiskSpaceRequest")
	proto.RegisterType((*GetDiskSpaceResponse)(nil), "diskspace.GetDiskSpaceResponse")
	proto.RegisterType((*DiskSpace)(nil), "diskspace.DiskSpace")
	proto.RegisterType((*DailyStorageUsageRequest)(nil), "diskspace.DailyStorageUsageRequest")
	proto.RegisterType((*DailyStorageUsageResponse)(nil), "diskspace.DailyStorageUsageResponse")
	proto.RegisterType((*DailyStorageUsageResponse_StorageUsage)(nil), "diskspace.DailyStorageUsageResponse.StorageUsage")
	proto.RegisterType((*SatelliteSummaryRequest)(nil), "diskspace.SatelliteSummaryRequest")
	proto.RegisterType((*SatelliteSummaryResponse)(nil), "diskspace.SatelliteSummaryResponse")
}

func init() { proto.RegisterFile("diskspace.proto", fileDescriptor_9d1904cedee84a32) }

var fileDescriptor_9d1904cedee84a32 = []byte{
	// 528 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x53, 0xc1, 0x6e, 0xd3, 0x40,
	0x10, 0xc5, 0x4e, 0x08, 0xcd, 0xc4, 0x01, 0xba, 0x0d, 0xaa, 0xb1, 0x2a, 0x52, 0x39, 0x1c, 0x7a,
	0x72, 0xd4, 0x94, 0x03, 0x37, 0xa4, 0x28, 0x12, 0x8a, 0x90, 0x40, 0x72, 0xca, 0x05, 0x24, 0xac,
	0x0d, 0xde, 0x9a, 0xa5, 0x76, 0xd7, 0x78, 0xc7, 0x91, 0xfa, 0x15, 0xf0, 0x03, 0xfc, 0x09, 0xdc,
	0xf9, 0x06, 0x0e, 0xe5, 0x57, 0xd0, 0xae, 0x13, 0xdb, 0x69, 0x9b, 0xaa, 0x1c, 0xb9, 0xed, 0xcc,
	0xce, 0x9b, 0x7d, 0xfb, 0xde, 0x0c, 0x3c, 0x08, 0xb9, 0x3c, 0x95, 0x29, 0xfd, 0xc8, 0xbc, 0x34,
	0x13, 0x28, 0x48, 0xbb, 0x4c, 0x38, 0x10, 0x89, 0x48, 0x14, 0x69, 0xa7, 0x1f, 0x09, 0x11, 0xc5,
	0x6c, 0xa8, 0xa3, 0x79, 0x7e, 0x32, 0x44, 0x9e, 0x30, 0x89, 0x34, 0x49, 0x8b, 0x02, 0xf7, 0x11,
	0xec, 0xbc, 0x64, 0x38, 0xe1, 0xf2, 0x74, 0xa6, 0xc0, 0x3e, 0xfb, 0x92, 0x33, 0x89, 0xee, 0x2b,
	0xe8, 0xad, 0xa7, 0x65, 0x2a, 0xce, 0x24, 0x23, 0x47, 0x00, 0xea, 0xa1, 0x40, 0xbf, 0x64, 0x1b,
	0xfb, 0xc6, 0x41, 0x67, 0xd4, 0xf3, 0x2a, 0x32, 0x15, 0x42, 0x13, 0xd2, 0x47, 0x57, 0x40, 0xbb,
	0xcc, 0x13, 0x02, 0xcd, 0x5c, 0xb2, 0x50, 0x63, 0x1b, 0xbe, 0x3e, 0x93, 0x3d, 0x68, 0xd3, 0x05,
	0xe5, 0x31, 0x9d, 0xc7, 0xcc, 0x36, 0xf5, 0x45, 0x95, 0x20, 0x3d, 0xb8, 0x8b, 0x19, 0x95, 0x9f,
	0xec, 0x86, 0xbe, 0x29, 0x02, 0xe2, 0xc0, 0x96, 0x58, 0xb0, 0x4c, 0xf7, 0x6a, 0xea, 0x8b, 0x32,
	0x76, 0x7f, 0x1a, 0x60, 0x4f, 0x28, 0x8f, 0xcf, 0x67, 0x28, 0x32, 0x1a, 0xb1, 0xb7, 0x92, 0x46,
	0xab, 0xaf, 0x91, 0xe7, 0xd0, 0x3c, 0xc9, 0x44, 0xb2, 0x24, 0xef, 0x78, 0x85, 0x42, 0xde, 0x4a,
	0x21, 0xef, 0x78, 0xa5, 0xd0, 0x78, 0xeb, 0xd7, 0x45, 0xff, 0xce, 0xb7, 0x3f, 0x7d, 0xc3, 0xd7,
	0x08, 0xf2, 0x0c, 0x4c, 0x14, 0x9a, 0xdf, 0x6d, 0x71, 0x26, 0x0a, 0x72, 0x08, 0x96, 0xa4, 0xc8,
	0xe2, 0x98, 0x23, 0x0b, 0x78, 0xa8, 0x7f, 0x61, 0x8d, 0xef, 0xab, 0x9a, 0xdf, 0x17, 0xfd, 0xd6,
	0x6b, 0x11, 0xb2, 0xe9, 0xc4, 0xef, 0x94, 0x35, 0xd3, 0xd0, 0xfd, 0x6a, 0xc2, 0xe3, 0x6b, 0xf8,
	0x2f, 0x3d, 0xd8, 0x85, 0x7b, 0x67, 0x22, 0xd4, 0xbd, 0xd4, 0x1f, 0x2c, 0xbf, 0xa5, 0xc2, 0x69,
	0x48, 0x28, 0xec, 0x84, 0x0a, 0x15, 0xc8, 0x02, 0x16, 0xe4, 0x0a, 0x67, 0x9b, 0xfb, 0x8d, 0x83,
	0xce, 0xe8, 0xb0, 0xee, 0xd2, 0xa6, 0xde, 0xde, 0x5a, 0x72, 0x3b, 0xbc, 0x5c, 0xe7, 0x2c, 0xc0,
	0xaa, 0xc7, 0xc4, 0x85, 0x2e, 0xc5, 0x20, 0x63, 0x12, 0x03, 0x14, 0x48, 0x63, 0xcd, 0xc8, 0xf0,
	0x3b, 0x14, 0x7d, 0x26, 0xf1, 0x58, 0xa5, 0xc8, 0x18, 0xda, 0xe5, 0xd4, 0xfd, 0x93, 0x7a, 0x15,
	0xcc, 0xfd, 0x61, 0xc0, 0xee, 0x6c, 0xa5, 0xd0, 0x2c, 0x4f, 0x12, 0x9a, 0x9d, 0xff, 0x47, 0x86,
	0xbe, 0x00, 0xfb, 0x2a, 0xfb, 0xa5, 0x9d, 0x03, 0xe8, 0xae, 0xfb, 0x55, 0x48, 0x68, 0xc9, 0x9a,
	0xce, 0xa3, 0xef, 0x26, 0x74, 0x55, 0xe3, 0x6a, 0x8f, 0xde, 0x80, 0x55, 0xdf, 0x50, 0xf2, 0xa4,
	0xe6, 0xef, 0x35, 0x1b, 0xed, 0xf4, 0x37, 0xde, 0x2f, 0x79, 0x7c, 0x80, 0xed, 0x2b, 0x73, 0x41,
	0x06, 0x37, 0x4f, 0x4d, 0xd1, 0xfa, 0xe9, 0x6d, 0x46, 0x8b, 0xbc, 0x87, 0x87, 0x97, 0x35, 0x20,
	0x6e, 0x0d, 0xb9, 0xc1, 0x5e, 0x67, 0x70, 0x63, 0x4d, 0xd1, 0x7c, 0xbc, 0xf7, 0xce, 0x51, 0x7a,
	0x7d, 0xf6, 0xb8, 0x18, 0xea, 0xc3, 0x30, 0xc9, 0x63, 0xe4, 0x6a, 0x31, 0xd2, 0xf9, 0xbc, 0xa5,
	0x3d, 0x3d, 0xfa, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xb3, 0xd3, 0x33, 0x3c, 0x36, 0x05, 0x00, 0x00,
}

// --- DRPC BEGIN ---

type DRPCNodeDiskSpaceClient interface {
	DRPCConn() drpc.Conn

	GetDiskSpace(ctx context.Context, in *GetDiskSpaceRequest) (*GetDiskSpaceResponse, error)
	DailyStorageUsage(ctx context.Context, in *DailyStorageUsageRequest) (*DailyStorageUsageResponse, error)
	SatelliteSummary(ctx context.Context, in *SatelliteSummaryRequest) (*SatelliteSummaryResponse, error)
}

type drpcNodeDiskSpaceClient struct {
	cc drpc.Conn
}

func NewDRPCNodeDiskSpaceClient(cc drpc.Conn) DRPCNodeDiskSpaceClient {
	return &drpcNodeDiskSpaceClient{cc}
}

func (c *drpcNodeDiskSpaceClient) DRPCConn() drpc.Conn { return c.cc }

func (c *drpcNodeDiskSpaceClient) GetDiskSpace(ctx context.Context, in *GetDiskSpaceRequest) (*GetDiskSpaceResponse, error) {
	out := new(GetDiskSpaceResponse)
	err := c.cc.Invoke(ctx, "/diskspace.NodeDiskSpace/GetDiskSpace", in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *drpcNodeDiskSpaceClient) DailyStorageUsage(ctx context.Context, in *DailyStorageUsageRequest) (*DailyStorageUsageResponse, error) {
	out := new(DailyStorageUsageResponse)
	err := c.cc.Invoke(ctx, "/diskspace.NodeDiskSpace/DailyStorageUsage", in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *drpcNodeDiskSpaceClient) SatelliteSummary(ctx context.Context, in *SatelliteSummaryRequest) (*SatelliteSummaryResponse, error) {
	out := new(SatelliteSummaryResponse)
	err := c.cc.Invoke(ctx, "/diskspace.NodeDiskSpace/SatelliteSummary", in, out)
	if err != nil {
		return nil, err
	}
	return out, nil
}

type DRPCNodeDiskSpaceServer interface {
	GetDiskSpace(context.Context, *GetDiskSpaceRequest) (*GetDiskSpaceResponse, error)
	DailyStorageUsage(context.Context, *DailyStorageUsageRequest) (*DailyStorageUsageResponse, error)
	SatelliteSummary(context.Context, *SatelliteSummaryRequest) (*SatelliteSummaryResponse, error)
}

type DRPCNodeDiskSpaceDescription struct{}

func (DRPCNodeDiskSpaceDescription) NumMethods() int { return 3 }

func (DRPCNodeDiskSpaceDescription) Method(n int) (string, drpc.Receiver, interface{}, bool) {
	switch n {
	case 0:
		return "/diskspace.NodeDiskSpace/GetDiskSpace",
			func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) {
				return srv.(DRPCNodeDiskSpaceServer).
					GetDiskSpace(
						ctx,
						in1.(*GetDiskSpaceRequest),
					)
			}, DRPCNodeDiskSpaceServer.GetDiskSpace, true
	case 1:
		return "/diskspace.NodeDiskSpace/DailyStorageUsage",
			func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) {
				return srv.(DRPCNodeDiskSpaceServer).
					DailyStorageUsage(
						ctx,
						in1.(*DailyStorageUsageRequest),
					)
			}, DRPCNodeDiskSpaceServer.DailyStorageUsage, true
	case 2:
		return "/diskspace.NodeDiskSpace/SatelliteSummary",
			func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) {
				return srv.(DRPCNodeDiskSpaceServer).
					SatelliteSummary(
						ctx,
						in1.(*SatelliteSummaryRequest),
					)
			}, DRPCNodeDiskSpaceServer.SatelliteSummary, true
	default:
		return "", nil, nil, false
	}
}

func DRPCRegisterNodeDiskSpace(mux drpc.Mux, impl DRPCNodeDiskSpaceServer) error {
	return mux.Register(impl, DRPCNodeDiskSpaceDescription{})
}

type DRPCNodeDiskSpace_GetDiskSpaceStream interface {
	drpc.Stream
	SendAndClose(*GetDiskSpaceResponse) error
}

type drpcNodeDiskSpaceGetDiskSpaceStream struct {
	drpc.Stream
}

func (x *drpcNodeDiskSpaceGetDiskSpaceStream) SendAndClose(m *GetDiskSpaceResponse) error {
	if err := x.MsgSend(m); err != nil {
		return err
	}
	return x.CloseSend()
}

type DRPCNodeDiskSpace_DailyStorageUsageStream interface {
	drpc.Stream
	SendAndClose(*DailyStorageUsageResponse) error
}

type drpcNodeDiskSpaceDailyStorageUsageStream struct {
	drpc.Stream
}

func (x *drpcNodeDiskSpaceDailyStorageUsageStream) SendAndClose(m *DailyStorageUsageResponse) error {
	if err := x.MsgSend(m); err != nil {
		return err
	}
	return x.CloseSend()
}

type DRPCNodeDiskSpace_SatelliteSummaryStream interface {
	drpc.Stream
	SendAndClose(*SatelliteSummaryResponse) error
}

type drpcNodeDiskSpaceSatelliteSummaryStream struct {
	drpc.Stream
}

func (x *drpcNodeDiskSpaceSatelliteSummaryStream) SendAndClose(m *SatelliteSummaryResponse) error {
	if err := x.MsgSend(m); err != nil {
		return err
	}
	return x.CloseSend()
}

// --- DRPC END ---