zsys_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v3.21.12
// source: zsys.proto

package zsys

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

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

const (
	Zsys_Version_FullMethodName              = "/zsys.Zsys/Version"
	Zsys_CreateUserData_FullMethodName       = "/zsys.Zsys/CreateUserData"
	Zsys_ChangeHomeOnUserData_FullMethodName = "/zsys.Zsys/ChangeHomeOnUserData"
	Zsys_DissociateUser_FullMethodName       = "/zsys.Zsys/DissociateUser"
	Zsys_PrepareBoot_FullMethodName          = "/zsys.Zsys/PrepareBoot"
	Zsys_CommitBoot_FullMethodName           = "/zsys.Zsys/CommitBoot"
	Zsys_UpdateBootMenu_FullMethodName       = "/zsys.Zsys/UpdateBootMenu"
	Zsys_UpdateLastUsed_FullMethodName       = "/zsys.Zsys/UpdateLastUsed"
	Zsys_SaveSystemState_FullMethodName      = "/zsys.Zsys/SaveSystemState"
	Zsys_SaveUserState_FullMethodName        = "/zsys.Zsys/SaveUserState"
	Zsys_RemoveSystemState_FullMethodName    = "/zsys.Zsys/RemoveSystemState"
	Zsys_RemoveUserState_FullMethodName      = "/zsys.Zsys/RemoveUserState"
	Zsys_DumpStates_FullMethodName           = "/zsys.Zsys/DumpStates"
	Zsys_DaemonStop_FullMethodName           = "/zsys.Zsys/DaemonStop"
	Zsys_LoggingLevel_FullMethodName         = "/zsys.Zsys/LoggingLevel"
	Zsys_Refresh_FullMethodName              = "/zsys.Zsys/Refresh"
	Zsys_Trace_FullMethodName                = "/zsys.Zsys/Trace"
	Zsys_Status_FullMethodName               = "/zsys.Zsys/Status"
	Zsys_Reload_FullMethodName               = "/zsys.Zsys/Reload"
	Zsys_GC_FullMethodName                   = "/zsys.Zsys/GC"
	Zsys_MachineShow_FullMethodName          = "/zsys.Zsys/MachineShow"
	Zsys_MachineList_FullMethodName          = "/zsys.Zsys/MachineList"
)

// ZsysClient is the client API for Zsys service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type ZsysClient interface {
	Version(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_VersionClient, error)
	CreateUserData(ctx context.Context, in *CreateUserDataRequest, opts ...grpc.CallOption) (Zsys_CreateUserDataClient, error)
	ChangeHomeOnUserData(ctx context.Context, in *ChangeHomeOnUserDataRequest, opts ...grpc.CallOption) (Zsys_ChangeHomeOnUserDataClient, error)
	DissociateUser(ctx context.Context, in *DissociateUserRequest, opts ...grpc.CallOption) (Zsys_DissociateUserClient, error)
	PrepareBoot(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_PrepareBootClient, error)
	CommitBoot(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_CommitBootClient, error)
	UpdateBootMenu(ctx context.Context, in *UpdateBootMenuRequest, opts ...grpc.CallOption) (Zsys_UpdateBootMenuClient, error)
	UpdateLastUsed(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_UpdateLastUsedClient, error)
	SaveSystemState(ctx context.Context, in *SaveSystemStateRequest, opts ...grpc.CallOption) (Zsys_SaveSystemStateClient, error)
	SaveUserState(ctx context.Context, in *SaveUserStateRequest, opts ...grpc.CallOption) (Zsys_SaveUserStateClient, error)
	RemoveSystemState(ctx context.Context, in *RemoveSystemStateRequest, opts ...grpc.CallOption) (Zsys_RemoveSystemStateClient, error)
	RemoveUserState(ctx context.Context, in *RemoveUserStateRequest, opts ...grpc.CallOption) (Zsys_RemoveUserStateClient, error)
	DumpStates(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_DumpStatesClient, error)
	DaemonStop(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_DaemonStopClient, error)
	LoggingLevel(ctx context.Context, in *LoggingLevelRequest, opts ...grpc.CallOption) (Zsys_LoggingLevelClient, error)
	Refresh(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_RefreshClient, error)
	Trace(ctx context.Context, in *TraceRequest, opts ...grpc.CallOption) (Zsys_TraceClient, error)
	Status(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_StatusClient, error)
	Reload(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_ReloadClient, error)
	GC(ctx context.Context, in *GCRequest, opts ...grpc.CallOption) (Zsys_GCClient, error)
	MachineShow(ctx context.Context, in *MachineShowRequest, opts ...grpc.CallOption) (Zsys_MachineShowClient, error)
	MachineList(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_MachineListClient, error)
}

type zsysClient struct {
	cc grpc.ClientConnInterface
}

func NewZsysClient(cc grpc.ClientConnInterface) ZsysClient {
	return &zsysClient{cc}
}

func (c *zsysClient) Version(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_VersionClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[0], Zsys_Version_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysVersionClient{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 Zsys_VersionClient interface {
	Recv() (*VersionResponse, error)
	grpc.ClientStream
}

type zsysVersionClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) CreateUserData(ctx context.Context, in *CreateUserDataRequest, opts ...grpc.CallOption) (Zsys_CreateUserDataClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[1], Zsys_CreateUserData_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysCreateUserDataClient{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 Zsys_CreateUserDataClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysCreateUserDataClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) ChangeHomeOnUserData(ctx context.Context, in *ChangeHomeOnUserDataRequest, opts ...grpc.CallOption) (Zsys_ChangeHomeOnUserDataClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[2], Zsys_ChangeHomeOnUserData_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysChangeHomeOnUserDataClient{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 Zsys_ChangeHomeOnUserDataClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysChangeHomeOnUserDataClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) DissociateUser(ctx context.Context, in *DissociateUserRequest, opts ...grpc.CallOption) (Zsys_DissociateUserClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[3], Zsys_DissociateUser_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysDissociateUserClient{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 Zsys_DissociateUserClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysDissociateUserClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) PrepareBoot(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_PrepareBootClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[4], Zsys_PrepareBoot_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysPrepareBootClient{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 Zsys_PrepareBootClient interface {
	Recv() (*PrepareBootResponse, error)
	grpc.ClientStream
}

type zsysPrepareBootClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) CommitBoot(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_CommitBootClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[5], Zsys_CommitBoot_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysCommitBootClient{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 Zsys_CommitBootClient interface {
	Recv() (*CommitBootResponse, error)
	grpc.ClientStream
}

type zsysCommitBootClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) UpdateBootMenu(ctx context.Context, in *UpdateBootMenuRequest, opts ...grpc.CallOption) (Zsys_UpdateBootMenuClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[6], Zsys_UpdateBootMenu_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysUpdateBootMenuClient{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 Zsys_UpdateBootMenuClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysUpdateBootMenuClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) UpdateLastUsed(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_UpdateLastUsedClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[7], Zsys_UpdateLastUsed_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysUpdateLastUsedClient{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 Zsys_UpdateLastUsedClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysUpdateLastUsedClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) SaveSystemState(ctx context.Context, in *SaveSystemStateRequest, opts ...grpc.CallOption) (Zsys_SaveSystemStateClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[8], Zsys_SaveSystemState_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysSaveSystemStateClient{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 Zsys_SaveSystemStateClient interface {
	Recv() (*CreateSaveStateResponse, error)
	grpc.ClientStream
}

type zsysSaveSystemStateClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) SaveUserState(ctx context.Context, in *SaveUserStateRequest, opts ...grpc.CallOption) (Zsys_SaveUserStateClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[9], Zsys_SaveUserState_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysSaveUserStateClient{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 Zsys_SaveUserStateClient interface {
	Recv() (*CreateSaveStateResponse, error)
	grpc.ClientStream
}

type zsysSaveUserStateClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) RemoveSystemState(ctx context.Context, in *RemoveSystemStateRequest, opts ...grpc.CallOption) (Zsys_RemoveSystemStateClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[10], Zsys_RemoveSystemState_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysRemoveSystemStateClient{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 Zsys_RemoveSystemStateClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysRemoveSystemStateClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) RemoveUserState(ctx context.Context, in *RemoveUserStateRequest, opts ...grpc.CallOption) (Zsys_RemoveUserStateClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[11], Zsys_RemoveUserState_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysRemoveUserStateClient{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 Zsys_RemoveUserStateClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysRemoveUserStateClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) DumpStates(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_DumpStatesClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[12], Zsys_DumpStates_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysDumpStatesClient{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 Zsys_DumpStatesClient interface {
	Recv() (*DumpStatesResponse, error)
	grpc.ClientStream
}

type zsysDumpStatesClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) DaemonStop(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_DaemonStopClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[13], Zsys_DaemonStop_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysDaemonStopClient{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 Zsys_DaemonStopClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysDaemonStopClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) LoggingLevel(ctx context.Context, in *LoggingLevelRequest, opts ...grpc.CallOption) (Zsys_LoggingLevelClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[14], Zsys_LoggingLevel_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysLoggingLevelClient{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 Zsys_LoggingLevelClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysLoggingLevelClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) Refresh(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_RefreshClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[15], Zsys_Refresh_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysRefreshClient{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 Zsys_RefreshClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysRefreshClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) Trace(ctx context.Context, in *TraceRequest, opts ...grpc.CallOption) (Zsys_TraceClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[16], Zsys_Trace_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysTraceClient{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 Zsys_TraceClient interface {
	Recv() (*TraceResponse, error)
	grpc.ClientStream
}

type zsysTraceClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) Status(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_StatusClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[17], Zsys_Status_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysStatusClient{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 Zsys_StatusClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysStatusClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) Reload(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_ReloadClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[18], Zsys_Reload_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysReloadClient{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 Zsys_ReloadClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysReloadClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) GC(ctx context.Context, in *GCRequest, opts ...grpc.CallOption) (Zsys_GCClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[19], Zsys_GC_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysGCClient{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 Zsys_GCClient interface {
	Recv() (*LogResponse, error)
	grpc.ClientStream
}

type zsysGCClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) MachineShow(ctx context.Context, in *MachineShowRequest, opts ...grpc.CallOption) (Zsys_MachineShowClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[20], Zsys_MachineShow_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysMachineShowClient{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 Zsys_MachineShowClient interface {
	Recv() (*MachineShowResponse, error)
	grpc.ClientStream
}

type zsysMachineShowClient struct {
	grpc.ClientStream
}

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

func (c *zsysClient) MachineList(ctx context.Context, in *Empty, opts ...grpc.CallOption) (Zsys_MachineListClient, error) {
	stream, err := c.cc.NewStream(ctx, &Zsys_ServiceDesc.Streams[21], Zsys_MachineList_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &zsysMachineListClient{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 Zsys_MachineListClient interface {
	Recv() (*MachineListResponse, error)
	grpc.ClientStream
}

type zsysMachineListClient struct {
	grpc.ClientStream
}

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

// ZsysServer is the server API for Zsys service.
// All implementations should embed UnimplementedZsysServer
// for forward compatibility
type ZsysServer interface {
	Version(*Empty, Zsys_VersionServer) error
	CreateUserData(*CreateUserDataRequest, Zsys_CreateUserDataServer) error
	ChangeHomeOnUserData(*ChangeHomeOnUserDataRequest, Zsys_ChangeHomeOnUserDataServer) error
	DissociateUser(*DissociateUserRequest, Zsys_DissociateUserServer) error
	PrepareBoot(*Empty, Zsys_PrepareBootServer) error
	CommitBoot(*Empty, Zsys_CommitBootServer) error
	UpdateBootMenu(*UpdateBootMenuRequest, Zsys_UpdateBootMenuServer) error
	UpdateLastUsed(*Empty, Zsys_UpdateLastUsedServer) error
	SaveSystemState(*SaveSystemStateRequest, Zsys_SaveSystemStateServer) error
	SaveUserState(*SaveUserStateRequest, Zsys_SaveUserStateServer) error
	RemoveSystemState(*RemoveSystemStateRequest, Zsys_RemoveSystemStateServer) error
	RemoveUserState(*RemoveUserStateRequest, Zsys_RemoveUserStateServer) error
	DumpStates(*Empty, Zsys_DumpStatesServer) error
	DaemonStop(*Empty, Zsys_DaemonStopServer) error
	LoggingLevel(*LoggingLevelRequest, Zsys_LoggingLevelServer) error
	Refresh(*Empty, Zsys_RefreshServer) error
	Trace(*TraceRequest, Zsys_TraceServer) error
	Status(*Empty, Zsys_StatusServer) error
	Reload(*Empty, Zsys_ReloadServer) error
	GC(*GCRequest, Zsys_GCServer) error
	MachineShow(*MachineShowRequest, Zsys_MachineShowServer) error
	MachineList(*Empty, Zsys_MachineListServer) error
}

// UnimplementedZsysServer should be embedded to have forward compatible implementations.
type UnimplementedZsysServer struct {
}

func (UnimplementedZsysServer) Version(*Empty, Zsys_VersionServer) error {
	return status.Errorf(codes.Unimplemented, "method Version not implemented")
}
func (UnimplementedZsysServer) CreateUserData(*CreateUserDataRequest, Zsys_CreateUserDataServer) error {
	return status.Errorf(codes.Unimplemented, "method CreateUserData not implemented")
}
func (UnimplementedZsysServer) ChangeHomeOnUserData(*ChangeHomeOnUserDataRequest, Zsys_ChangeHomeOnUserDataServer) error {
	return status.Errorf(codes.Unimplemented, "method ChangeHomeOnUserData not implemented")
}
func (UnimplementedZsysServer) DissociateUser(*DissociateUserRequest, Zsys_DissociateUserServer) error {
	return status.Errorf(codes.Unimplemented, "method DissociateUser not implemented")
}
func (UnimplementedZsysServer) PrepareBoot(*Empty, Zsys_PrepareBootServer) error {
	return status.Errorf(codes.Unimplemented, "method PrepareBoot not implemented")
}
func (UnimplementedZsysServer) CommitBoot(*Empty, Zsys_CommitBootServer) error {
	return status.Errorf(codes.Unimplemented, "method CommitBoot not implemented")
}
func (UnimplementedZsysServer) UpdateBootMenu(*UpdateBootMenuRequest, Zsys_UpdateBootMenuServer) error {
	return status.Errorf(codes.Unimplemented, "method UpdateBootMenu not implemented")
}
func (UnimplementedZsysServer) UpdateLastUsed(*Empty, Zsys_UpdateLastUsedServer) error {
	return status.Errorf(codes.Unimplemented, "method UpdateLastUsed not implemented")
}
func (UnimplementedZsysServer) SaveSystemState(*SaveSystemStateRequest, Zsys_SaveSystemStateServer) error {
	return status.Errorf(codes.Unimplemented, "method SaveSystemState not implemented")
}
func (UnimplementedZsysServer) SaveUserState(*SaveUserStateRequest, Zsys_SaveUserStateServer) error {
	return status.Errorf(codes.Unimplemented, "method SaveUserState not implemented")
}
func (UnimplementedZsysServer) RemoveSystemState(*RemoveSystemStateRequest, Zsys_RemoveSystemStateServer) error {
	return status.Errorf(codes.Unimplemented, "method RemoveSystemState not implemented")
}
func (UnimplementedZsysServer) RemoveUserState(*RemoveUserStateRequest, Zsys_RemoveUserStateServer) error {
	return status.Errorf(codes.Unimplemented, "method RemoveUserState not implemented")
}
func (UnimplementedZsysServer) DumpStates(*Empty, Zsys_DumpStatesServer) error {
	return status.Errorf(codes.Unimplemented, "method DumpStates not implemented")
}
func (UnimplementedZsysServer) DaemonStop(*Empty, Zsys_DaemonStopServer) error {
	return status.Errorf(codes.Unimplemented, "method DaemonStop not implemented")
}
func (UnimplementedZsysServer) LoggingLevel(*LoggingLevelRequest, Zsys_LoggingLevelServer) error {
	return status.Errorf(codes.Unimplemented, "method LoggingLevel not implemented")
}
func (UnimplementedZsysServer) Refresh(*Empty, Zsys_RefreshServer) error {
	return status.Errorf(codes.Unimplemented, "method Refresh not implemented")
}
func (UnimplementedZsysServer) Trace(*TraceRequest, Zsys_TraceServer) error {
	return status.Errorf(codes.Unimplemented, "method Trace not implemented")
}
func (UnimplementedZsysServer) Status(*Empty, Zsys_StatusServer) error {
	return status.Errorf(codes.Unimplemented, "method Status not implemented")
}
func (UnimplementedZsysServer) Reload(*Empty, Zsys_ReloadServer) error {
	return status.Errorf(codes.Unimplemented, "method Reload not implemented")
}
func (UnimplementedZsysServer) GC(*GCRequest, Zsys_GCServer) error {
	return status.Errorf(codes.Unimplemented, "method GC not implemented")
}
func (UnimplementedZsysServer) MachineShow(*MachineShowRequest, Zsys_MachineShowServer) error {
	return status.Errorf(codes.Unimplemented, "method MachineShow not implemented")
}
func (UnimplementedZsysServer) MachineList(*Empty, Zsys_MachineListServer) error {
	return status.Errorf(codes.Unimplemented, "method MachineList not implemented")
}

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

func RegisterZsysServer(s grpc.ServiceRegistrar, srv ZsysServer) {
	s.RegisterService(&Zsys_ServiceDesc, srv)
}

func _Zsys_Version_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).Version(m, &zsysVersionServer{stream})
}

type Zsys_VersionServer interface {
	Send(*VersionResponse) error
	grpc.ServerStream
}

type zsysVersionServer struct {
	grpc.ServerStream
}

func (x *zsysVersionServer) Send(m *VersionResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_CreateUserData_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CreateUserDataRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).CreateUserData(m, &zsysCreateUserDataServer{stream})
}

type Zsys_CreateUserDataServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysCreateUserDataServer struct {
	grpc.ServerStream
}

func (x *zsysCreateUserDataServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_ChangeHomeOnUserData_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ChangeHomeOnUserDataRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).ChangeHomeOnUserData(m, &zsysChangeHomeOnUserDataServer{stream})
}

type Zsys_ChangeHomeOnUserDataServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysChangeHomeOnUserDataServer struct {
	grpc.ServerStream
}

func (x *zsysChangeHomeOnUserDataServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_DissociateUser_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DissociateUserRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).DissociateUser(m, &zsysDissociateUserServer{stream})
}

type Zsys_DissociateUserServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysDissociateUserServer struct {
	grpc.ServerStream
}

func (x *zsysDissociateUserServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_PrepareBoot_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).PrepareBoot(m, &zsysPrepareBootServer{stream})
}

type Zsys_PrepareBootServer interface {
	Send(*PrepareBootResponse) error
	grpc.ServerStream
}

type zsysPrepareBootServer struct {
	grpc.ServerStream
}

func (x *zsysPrepareBootServer) Send(m *PrepareBootResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_CommitBoot_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).CommitBoot(m, &zsysCommitBootServer{stream})
}

type Zsys_CommitBootServer interface {
	Send(*CommitBootResponse) error
	grpc.ServerStream
}

type zsysCommitBootServer struct {
	grpc.ServerStream
}

func (x *zsysCommitBootServer) Send(m *CommitBootResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_UpdateBootMenu_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(UpdateBootMenuRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).UpdateBootMenu(m, &zsysUpdateBootMenuServer{stream})
}

type Zsys_UpdateBootMenuServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysUpdateBootMenuServer struct {
	grpc.ServerStream
}

func (x *zsysUpdateBootMenuServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_UpdateLastUsed_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).UpdateLastUsed(m, &zsysUpdateLastUsedServer{stream})
}

type Zsys_UpdateLastUsedServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysUpdateLastUsedServer struct {
	grpc.ServerStream
}

func (x *zsysUpdateLastUsedServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_SaveSystemState_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SaveSystemStateRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).SaveSystemState(m, &zsysSaveSystemStateServer{stream})
}

type Zsys_SaveSystemStateServer interface {
	Send(*CreateSaveStateResponse) error
	grpc.ServerStream
}

type zsysSaveSystemStateServer struct {
	grpc.ServerStream
}

func (x *zsysSaveSystemStateServer) Send(m *CreateSaveStateResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_SaveUserState_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SaveUserStateRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).SaveUserState(m, &zsysSaveUserStateServer{stream})
}

type Zsys_SaveUserStateServer interface {
	Send(*CreateSaveStateResponse) error
	grpc.ServerStream
}

type zsysSaveUserStateServer struct {
	grpc.ServerStream
}

func (x *zsysSaveUserStateServer) Send(m *CreateSaveStateResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_RemoveSystemState_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RemoveSystemStateRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).RemoveSystemState(m, &zsysRemoveSystemStateServer{stream})
}

type Zsys_RemoveSystemStateServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysRemoveSystemStateServer struct {
	grpc.ServerStream
}

func (x *zsysRemoveSystemStateServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_RemoveUserState_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RemoveUserStateRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).RemoveUserState(m, &zsysRemoveUserStateServer{stream})
}

type Zsys_RemoveUserStateServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysRemoveUserStateServer struct {
	grpc.ServerStream
}

func (x *zsysRemoveUserStateServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_DumpStates_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).DumpStates(m, &zsysDumpStatesServer{stream})
}

type Zsys_DumpStatesServer interface {
	Send(*DumpStatesResponse) error
	grpc.ServerStream
}

type zsysDumpStatesServer struct {
	grpc.ServerStream
}

func (x *zsysDumpStatesServer) Send(m *DumpStatesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_DaemonStop_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).DaemonStop(m, &zsysDaemonStopServer{stream})
}

type Zsys_DaemonStopServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysDaemonStopServer struct {
	grpc.ServerStream
}

func (x *zsysDaemonStopServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_LoggingLevel_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LoggingLevelRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).LoggingLevel(m, &zsysLoggingLevelServer{stream})
}

type Zsys_LoggingLevelServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysLoggingLevelServer struct {
	grpc.ServerStream
}

func (x *zsysLoggingLevelServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_Refresh_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).Refresh(m, &zsysRefreshServer{stream})
}

type Zsys_RefreshServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysRefreshServer struct {
	grpc.ServerStream
}

func (x *zsysRefreshServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_Trace_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TraceRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).Trace(m, &zsysTraceServer{stream})
}

type Zsys_TraceServer interface {
	Send(*TraceResponse) error
	grpc.ServerStream
}

type zsysTraceServer struct {
	grpc.ServerStream
}

func (x *zsysTraceServer) Send(m *TraceResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_Status_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).Status(m, &zsysStatusServer{stream})
}

type Zsys_StatusServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysStatusServer struct {
	grpc.ServerStream
}

func (x *zsysStatusServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_Reload_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).Reload(m, &zsysReloadServer{stream})
}

type Zsys_ReloadServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysReloadServer struct {
	grpc.ServerStream
}

func (x *zsysReloadServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_GC_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GCRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).GC(m, &zsysGCServer{stream})
}

type Zsys_GCServer interface {
	Send(*LogResponse) error
	grpc.ServerStream
}

type zsysGCServer struct {
	grpc.ServerStream
}

func (x *zsysGCServer) Send(m *LogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_MachineShow_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(MachineShowRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).MachineShow(m, &zsysMachineShowServer{stream})
}

type Zsys_MachineShowServer interface {
	Send(*MachineShowResponse) error
	grpc.ServerStream
}

type zsysMachineShowServer struct {
	grpc.ServerStream
}

func (x *zsysMachineShowServer) Send(m *MachineShowResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Zsys_MachineList_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZsysServer).MachineList(m, &zsysMachineListServer{stream})
}

type Zsys_MachineListServer interface {
	Send(*MachineListResponse) error
	grpc.ServerStream
}

type zsysMachineListServer struct {
	grpc.ServerStream
}

func (x *zsysMachineListServer) Send(m *MachineListResponse) error {
	return x.ServerStream.SendMsg(m)
}

// Zsys_ServiceDesc is the grpc.ServiceDesc for Zsys service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Zsys_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "zsys.Zsys",
	HandlerType: (*ZsysServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Version",
			Handler:       _Zsys_Version_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CreateUserData",
			Handler:       _Zsys_CreateUserData_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ChangeHomeOnUserData",
			Handler:       _Zsys_ChangeHomeOnUserData_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DissociateUser",
			Handler:       _Zsys_DissociateUser_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "PrepareBoot",
			Handler:       _Zsys_PrepareBoot_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CommitBoot",
			Handler:       _Zsys_CommitBoot_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UpdateBootMenu",
			Handler:       _Zsys_UpdateBootMenu_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UpdateLastUsed",
			Handler:       _Zsys_UpdateLastUsed_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SaveSystemState",
			Handler:       _Zsys_SaveSystemState_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SaveUserState",
			Handler:       _Zsys_SaveUserState_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "RemoveSystemState",
			Handler:       _Zsys_RemoveSystemState_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "RemoveUserState",
			Handler:       _Zsys_RemoveUserState_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DumpStates",
			Handler:       _Zsys_DumpStates_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DaemonStop",
			Handler:       _Zsys_DaemonStop_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "LoggingLevel",
			Handler:       _Zsys_LoggingLevel_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Refresh",
			Handler:       _Zsys_Refresh_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Trace",
			Handler:       _Zsys_Trace_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Status",
			Handler:       _Zsys_Status_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Reload",
			Handler:       _Zsys_Reload_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GC",
			Handler:       _Zsys_GC_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "MachineShow",
			Handler:       _Zsys_MachineShow_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "MachineList",
			Handler:       _Zsys_MachineList_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "zsys.proto",
}