tabletmanagerservice.pb.go

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

/*
Package tabletmanagerservice is a generated protocol buffer package.

It is generated from these files:
	tabletmanagerservice.proto

It has these top-level messages:
*/
package tabletmanagerservice

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import tabletmanagerdata "github.com/youtube/vitess/go/vt/proto/tabletmanagerdata"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

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

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

// Client API for TabletManager service

type TabletManagerClient interface {
	// Ping returns the input payload
	Ping(ctx context.Context, in *tabletmanagerdata.PingRequest, opts ...grpc.CallOption) (*tabletmanagerdata.PingResponse, error)
	// Sleep sleeps for the provided duration
	Sleep(ctx context.Context, in *tabletmanagerdata.SleepRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SleepResponse, error)
	// ExecuteHook executes the hook remotely
	ExecuteHook(ctx context.Context, in *tabletmanagerdata.ExecuteHookRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ExecuteHookResponse, error)
	// GetSchema asks the tablet for its schema
	GetSchema(ctx context.Context, in *tabletmanagerdata.GetSchemaRequest, opts ...grpc.CallOption) (*tabletmanagerdata.GetSchemaResponse, error)
	// GetPermissions asks the tablet for its permissions
	GetPermissions(ctx context.Context, in *tabletmanagerdata.GetPermissionsRequest, opts ...grpc.CallOption) (*tabletmanagerdata.GetPermissionsResponse, error)
	SetReadOnly(ctx context.Context, in *tabletmanagerdata.SetReadOnlyRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SetReadOnlyResponse, error)
	SetReadWrite(ctx context.Context, in *tabletmanagerdata.SetReadWriteRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SetReadWriteResponse, error)
	// ChangeType asks the remote tablet to change its type
	ChangeType(ctx context.Context, in *tabletmanagerdata.ChangeTypeRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ChangeTypeResponse, error)
	Scrap(ctx context.Context, in *tabletmanagerdata.ScrapRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ScrapResponse, error)
	RefreshState(ctx context.Context, in *tabletmanagerdata.RefreshStateRequest, opts ...grpc.CallOption) (*tabletmanagerdata.RefreshStateResponse, error)
	RunHealthCheck(ctx context.Context, in *tabletmanagerdata.RunHealthCheckRequest, opts ...grpc.CallOption) (*tabletmanagerdata.RunHealthCheckResponse, error)
	ReloadSchema(ctx context.Context, in *tabletmanagerdata.ReloadSchemaRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ReloadSchemaResponse, error)
	PreflightSchema(ctx context.Context, in *tabletmanagerdata.PreflightSchemaRequest, opts ...grpc.CallOption) (*tabletmanagerdata.PreflightSchemaResponse, error)
	ApplySchema(ctx context.Context, in *tabletmanagerdata.ApplySchemaRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ApplySchemaResponse, error)
	ExecuteFetchAsDba(ctx context.Context, in *tabletmanagerdata.ExecuteFetchAsDbaRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ExecuteFetchAsDbaResponse, error)
	ExecuteFetchAsApp(ctx context.Context, in *tabletmanagerdata.ExecuteFetchAsAppRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ExecuteFetchAsAppResponse, error)
	// SlaveStatus returns the current slave status.
	SlaveStatus(ctx context.Context, in *tabletmanagerdata.SlaveStatusRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SlaveStatusResponse, error)
	// MasterPosition returns the current master position
	MasterPosition(ctx context.Context, in *tabletmanagerdata.MasterPositionRequest, opts ...grpc.CallOption) (*tabletmanagerdata.MasterPositionResponse, error)
	// StopSlave makes mysql stop its replication
	StopSlave(ctx context.Context, in *tabletmanagerdata.StopSlaveRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StopSlaveResponse, error)
	// StopSlaveMinimum stops the mysql replication after it reaches
	// the provided minimum point
	StopSlaveMinimum(ctx context.Context, in *tabletmanagerdata.StopSlaveMinimumRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StopSlaveMinimumResponse, error)
	// StartSlave starts the mysql replication
	StartSlave(ctx context.Context, in *tabletmanagerdata.StartSlaveRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StartSlaveResponse, error)
	// TabletExternallyReparented tells a tablet that its underlying MySQL is
	// currently the master. It is only used in environments (tabletmanagerdata.such as Vitess+MoB)
	// in which MySQL is reparented by some agent external to Vitess, and then
	// that agent simply notifies Vitess.
	//
	// This call is idempotent with respect to a single target tablet.
	// However, the tablet assumes there is a cooling-off period following the
	// initial external reparent from A to B, before this call is repeated on any
	// tablet other than B. This assumption is configurable with the vttablet flag
	// "finalize_external_reparent_timeout".
	//
	// For more information, see the design doc at go/vt-fast-failover.
	TabletExternallyReparented(ctx context.Context, in *tabletmanagerdata.TabletExternallyReparentedRequest, opts ...grpc.CallOption) (*tabletmanagerdata.TabletExternallyReparentedResponse, error)
	// TabletExternallyElected is an notification that may be sent in
	// anticipation of potentially later sending TabletExternallyReparented.
	// The tablet can use this extra lead time to prepare to react quickly if
	// TabletExternallyReparented does follow.
	//
	// This call is effectively a no-op if it is not followed by a call to
	// TabletExternallyReparented, so the external agent doing the reparent can
	// still change its mind.
	//
	// The agent does not need to wait for this call or cancel it before calling
	// TabletExternallyReparented if the external reparent operation finishes
	// before TabletExternallyElected returns.
	TabletExternallyElected(ctx context.Context, in *tabletmanagerdata.TabletExternallyElectedRequest, opts ...grpc.CallOption) (*tabletmanagerdata.TabletExternallyElectedResponse, error)
	// GetSlaves asks for the list of mysql slaves
	GetSlaves(ctx context.Context, in *tabletmanagerdata.GetSlavesRequest, opts ...grpc.CallOption) (*tabletmanagerdata.GetSlavesResponse, error)
	// WaitBlpPosition tells the remote tablet to wait until it reaches
	// the specified binolg player position
	WaitBlpPosition(ctx context.Context, in *tabletmanagerdata.WaitBlpPositionRequest, opts ...grpc.CallOption) (*tabletmanagerdata.WaitBlpPositionResponse, error)
	// StopBlp asks the tablet to stop all its binlog players,
	// and returns the current position for all of them
	StopBlp(ctx context.Context, in *tabletmanagerdata.StopBlpRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StopBlpResponse, error)
	// StartBlp asks the tablet to restart its binlog players
	StartBlp(ctx context.Context, in *tabletmanagerdata.StartBlpRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StartBlpResponse, error)
	// RunBlpUntil asks the tablet to restart its binlog players
	RunBlpUntil(ctx context.Context, in *tabletmanagerdata.RunBlpUntilRequest, opts ...grpc.CallOption) (*tabletmanagerdata.RunBlpUntilResponse, error)
	// ResetReplication makes the target not replicating
	ResetReplication(ctx context.Context, in *tabletmanagerdata.ResetReplicationRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ResetReplicationResponse, error)
	// InitMaster initializes the tablet as a master
	InitMaster(ctx context.Context, in *tabletmanagerdata.InitMasterRequest, opts ...grpc.CallOption) (*tabletmanagerdata.InitMasterResponse, error)
	// PopulateReparentJournal tells the tablet to add an entry to its
	// reparent journal
	PopulateReparentJournal(ctx context.Context, in *tabletmanagerdata.PopulateReparentJournalRequest, opts ...grpc.CallOption) (*tabletmanagerdata.PopulateReparentJournalResponse, error)
	// InitSlave tells the tablet to reparent to the master unconditionnally
	InitSlave(ctx context.Context, in *tabletmanagerdata.InitSlaveRequest, opts ...grpc.CallOption) (*tabletmanagerdata.InitSlaveResponse, error)
	// DemoteMaster tells the soon-to-be-former master it's gonna change
	DemoteMaster(ctx context.Context, in *tabletmanagerdata.DemoteMasterRequest, opts ...grpc.CallOption) (*tabletmanagerdata.DemoteMasterResponse, error)
	// PromoteSlaveWhenCaughtUp tells the remote tablet to catch up,
	// and then be the master
	PromoteSlaveWhenCaughtUp(ctx context.Context, in *tabletmanagerdata.PromoteSlaveWhenCaughtUpRequest, opts ...grpc.CallOption) (*tabletmanagerdata.PromoteSlaveWhenCaughtUpResponse, error)
	// SlaveWasPromoted tells the remote tablet it is now the master
	SlaveWasPromoted(ctx context.Context, in *tabletmanagerdata.SlaveWasPromotedRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SlaveWasPromotedResponse, error)
	// SetMaster tells the slave to reparent
	SetMaster(ctx context.Context, in *tabletmanagerdata.SetMasterRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SetMasterResponse, error)
	// SlaveWasRestarted tells the remote tablet its master has changed
	SlaveWasRestarted(ctx context.Context, in *tabletmanagerdata.SlaveWasRestartedRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SlaveWasRestartedResponse, error)
	// StopReplicationAndGetStatus stops MySQL replication, and returns the
	// replication status
	StopReplicationAndGetStatus(ctx context.Context, in *tabletmanagerdata.StopReplicationAndGetStatusRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StopReplicationAndGetStatusResponse, error)
	// PromoteSlave makes the slave the new master
	PromoteSlave(ctx context.Context, in *tabletmanagerdata.PromoteSlaveRequest, opts ...grpc.CallOption) (*tabletmanagerdata.PromoteSlaveResponse, error)
	Backup(ctx context.Context, in *tabletmanagerdata.BackupRequest, opts ...grpc.CallOption) (TabletManager_BackupClient, error)
}

type tabletManagerClient struct {
	cc *grpc.ClientConn
}

func NewTabletManagerClient(cc *grpc.ClientConn) TabletManagerClient {
	return &tabletManagerClient{cc}
}

func (c *tabletManagerClient) Ping(ctx context.Context, in *tabletmanagerdata.PingRequest, opts ...grpc.CallOption) (*tabletmanagerdata.PingResponse, error) {
	out := new(tabletmanagerdata.PingResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/Ping", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) Sleep(ctx context.Context, in *tabletmanagerdata.SleepRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SleepResponse, error) {
	out := new(tabletmanagerdata.SleepResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/Sleep", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) ExecuteHook(ctx context.Context, in *tabletmanagerdata.ExecuteHookRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ExecuteHookResponse, error) {
	out := new(tabletmanagerdata.ExecuteHookResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/ExecuteHook", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) GetSchema(ctx context.Context, in *tabletmanagerdata.GetSchemaRequest, opts ...grpc.CallOption) (*tabletmanagerdata.GetSchemaResponse, error) {
	out := new(tabletmanagerdata.GetSchemaResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/GetSchema", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) GetPermissions(ctx context.Context, in *tabletmanagerdata.GetPermissionsRequest, opts ...grpc.CallOption) (*tabletmanagerdata.GetPermissionsResponse, error) {
	out := new(tabletmanagerdata.GetPermissionsResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/GetPermissions", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) SetReadOnly(ctx context.Context, in *tabletmanagerdata.SetReadOnlyRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SetReadOnlyResponse, error) {
	out := new(tabletmanagerdata.SetReadOnlyResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/SetReadOnly", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) SetReadWrite(ctx context.Context, in *tabletmanagerdata.SetReadWriteRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SetReadWriteResponse, error) {
	out := new(tabletmanagerdata.SetReadWriteResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/SetReadWrite", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) ChangeType(ctx context.Context, in *tabletmanagerdata.ChangeTypeRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ChangeTypeResponse, error) {
	out := new(tabletmanagerdata.ChangeTypeResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/ChangeType", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) Scrap(ctx context.Context, in *tabletmanagerdata.ScrapRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ScrapResponse, error) {
	out := new(tabletmanagerdata.ScrapResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/Scrap", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) RefreshState(ctx context.Context, in *tabletmanagerdata.RefreshStateRequest, opts ...grpc.CallOption) (*tabletmanagerdata.RefreshStateResponse, error) {
	out := new(tabletmanagerdata.RefreshStateResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/RefreshState", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) RunHealthCheck(ctx context.Context, in *tabletmanagerdata.RunHealthCheckRequest, opts ...grpc.CallOption) (*tabletmanagerdata.RunHealthCheckResponse, error) {
	out := new(tabletmanagerdata.RunHealthCheckResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/RunHealthCheck", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) ReloadSchema(ctx context.Context, in *tabletmanagerdata.ReloadSchemaRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ReloadSchemaResponse, error) {
	out := new(tabletmanagerdata.ReloadSchemaResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/ReloadSchema", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) PreflightSchema(ctx context.Context, in *tabletmanagerdata.PreflightSchemaRequest, opts ...grpc.CallOption) (*tabletmanagerdata.PreflightSchemaResponse, error) {
	out := new(tabletmanagerdata.PreflightSchemaResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/PreflightSchema", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) ApplySchema(ctx context.Context, in *tabletmanagerdata.ApplySchemaRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ApplySchemaResponse, error) {
	out := new(tabletmanagerdata.ApplySchemaResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/ApplySchema", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) ExecuteFetchAsDba(ctx context.Context, in *tabletmanagerdata.ExecuteFetchAsDbaRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ExecuteFetchAsDbaResponse, error) {
	out := new(tabletmanagerdata.ExecuteFetchAsDbaResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/ExecuteFetchAsDba", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) ExecuteFetchAsApp(ctx context.Context, in *tabletmanagerdata.ExecuteFetchAsAppRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ExecuteFetchAsAppResponse, error) {
	out := new(tabletmanagerdata.ExecuteFetchAsAppResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/ExecuteFetchAsApp", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) SlaveStatus(ctx context.Context, in *tabletmanagerdata.SlaveStatusRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SlaveStatusResponse, error) {
	out := new(tabletmanagerdata.SlaveStatusResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/SlaveStatus", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) MasterPosition(ctx context.Context, in *tabletmanagerdata.MasterPositionRequest, opts ...grpc.CallOption) (*tabletmanagerdata.MasterPositionResponse, error) {
	out := new(tabletmanagerdata.MasterPositionResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/MasterPosition", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) StopSlave(ctx context.Context, in *tabletmanagerdata.StopSlaveRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StopSlaveResponse, error) {
	out := new(tabletmanagerdata.StopSlaveResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/StopSlave", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) StopSlaveMinimum(ctx context.Context, in *tabletmanagerdata.StopSlaveMinimumRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StopSlaveMinimumResponse, error) {
	out := new(tabletmanagerdata.StopSlaveMinimumResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/StopSlaveMinimum", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) StartSlave(ctx context.Context, in *tabletmanagerdata.StartSlaveRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StartSlaveResponse, error) {
	out := new(tabletmanagerdata.StartSlaveResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/StartSlave", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) TabletExternallyReparented(ctx context.Context, in *tabletmanagerdata.TabletExternallyReparentedRequest, opts ...grpc.CallOption) (*tabletmanagerdata.TabletExternallyReparentedResponse, error) {
	out := new(tabletmanagerdata.TabletExternallyReparentedResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/TabletExternallyReparented", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) TabletExternallyElected(ctx context.Context, in *tabletmanagerdata.TabletExternallyElectedRequest, opts ...grpc.CallOption) (*tabletmanagerdata.TabletExternallyElectedResponse, error) {
	out := new(tabletmanagerdata.TabletExternallyElectedResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/TabletExternallyElected", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) GetSlaves(ctx context.Context, in *tabletmanagerdata.GetSlavesRequest, opts ...grpc.CallOption) (*tabletmanagerdata.GetSlavesResponse, error) {
	out := new(tabletmanagerdata.GetSlavesResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/GetSlaves", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) WaitBlpPosition(ctx context.Context, in *tabletmanagerdata.WaitBlpPositionRequest, opts ...grpc.CallOption) (*tabletmanagerdata.WaitBlpPositionResponse, error) {
	out := new(tabletmanagerdata.WaitBlpPositionResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/WaitBlpPosition", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) StopBlp(ctx context.Context, in *tabletmanagerdata.StopBlpRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StopBlpResponse, error) {
	out := new(tabletmanagerdata.StopBlpResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/StopBlp", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) StartBlp(ctx context.Context, in *tabletmanagerdata.StartBlpRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StartBlpResponse, error) {
	out := new(tabletmanagerdata.StartBlpResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/StartBlp", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) RunBlpUntil(ctx context.Context, in *tabletmanagerdata.RunBlpUntilRequest, opts ...grpc.CallOption) (*tabletmanagerdata.RunBlpUntilResponse, error) {
	out := new(tabletmanagerdata.RunBlpUntilResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/RunBlpUntil", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) ResetReplication(ctx context.Context, in *tabletmanagerdata.ResetReplicationRequest, opts ...grpc.CallOption) (*tabletmanagerdata.ResetReplicationResponse, error) {
	out := new(tabletmanagerdata.ResetReplicationResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/ResetReplication", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) InitMaster(ctx context.Context, in *tabletmanagerdata.InitMasterRequest, opts ...grpc.CallOption) (*tabletmanagerdata.InitMasterResponse, error) {
	out := new(tabletmanagerdata.InitMasterResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/InitMaster", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) PopulateReparentJournal(ctx context.Context, in *tabletmanagerdata.PopulateReparentJournalRequest, opts ...grpc.CallOption) (*tabletmanagerdata.PopulateReparentJournalResponse, error) {
	out := new(tabletmanagerdata.PopulateReparentJournalResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/PopulateReparentJournal", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) InitSlave(ctx context.Context, in *tabletmanagerdata.InitSlaveRequest, opts ...grpc.CallOption) (*tabletmanagerdata.InitSlaveResponse, error) {
	out := new(tabletmanagerdata.InitSlaveResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/InitSlave", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) DemoteMaster(ctx context.Context, in *tabletmanagerdata.DemoteMasterRequest, opts ...grpc.CallOption) (*tabletmanagerdata.DemoteMasterResponse, error) {
	out := new(tabletmanagerdata.DemoteMasterResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/DemoteMaster", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) PromoteSlaveWhenCaughtUp(ctx context.Context, in *tabletmanagerdata.PromoteSlaveWhenCaughtUpRequest, opts ...grpc.CallOption) (*tabletmanagerdata.PromoteSlaveWhenCaughtUpResponse, error) {
	out := new(tabletmanagerdata.PromoteSlaveWhenCaughtUpResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/PromoteSlaveWhenCaughtUp", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) SlaveWasPromoted(ctx context.Context, in *tabletmanagerdata.SlaveWasPromotedRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SlaveWasPromotedResponse, error) {
	out := new(tabletmanagerdata.SlaveWasPromotedResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/SlaveWasPromoted", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) SetMaster(ctx context.Context, in *tabletmanagerdata.SetMasterRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SetMasterResponse, error) {
	out := new(tabletmanagerdata.SetMasterResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/SetMaster", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) SlaveWasRestarted(ctx context.Context, in *tabletmanagerdata.SlaveWasRestartedRequest, opts ...grpc.CallOption) (*tabletmanagerdata.SlaveWasRestartedResponse, error) {
	out := new(tabletmanagerdata.SlaveWasRestartedResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/SlaveWasRestarted", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) StopReplicationAndGetStatus(ctx context.Context, in *tabletmanagerdata.StopReplicationAndGetStatusRequest, opts ...grpc.CallOption) (*tabletmanagerdata.StopReplicationAndGetStatusResponse, error) {
	out := new(tabletmanagerdata.StopReplicationAndGetStatusResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/StopReplicationAndGetStatus", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) PromoteSlave(ctx context.Context, in *tabletmanagerdata.PromoteSlaveRequest, opts ...grpc.CallOption) (*tabletmanagerdata.PromoteSlaveResponse, error) {
	out := new(tabletmanagerdata.PromoteSlaveResponse)
	err := grpc.Invoke(ctx, "/tabletmanagerservice.TabletManager/PromoteSlave", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tabletManagerClient) Backup(ctx context.Context, in *tabletmanagerdata.BackupRequest, opts ...grpc.CallOption) (TabletManager_BackupClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_TabletManager_serviceDesc.Streams[0], c.cc, "/tabletmanagerservice.TabletManager/Backup", opts...)
	if err != nil {
		return nil, err
	}
	x := &tabletManagerBackupClient{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 TabletManager_BackupClient interface {
	Recv() (*tabletmanagerdata.BackupResponse, error)
	grpc.ClientStream
}

type tabletManagerBackupClient struct {
	grpc.ClientStream
}

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

// Server API for TabletManager service

type TabletManagerServer interface {
	// Ping returns the input payload
	Ping(context.Context, *tabletmanagerdata.PingRequest) (*tabletmanagerdata.PingResponse, error)
	// Sleep sleeps for the provided duration
	Sleep(context.Context, *tabletmanagerdata.SleepRequest) (*tabletmanagerdata.SleepResponse, error)
	// ExecuteHook executes the hook remotely
	ExecuteHook(context.Context, *tabletmanagerdata.ExecuteHookRequest) (*tabletmanagerdata.ExecuteHookResponse, error)
	// GetSchema asks the tablet for its schema
	GetSchema(context.Context, *tabletmanagerdata.GetSchemaRequest) (*tabletmanagerdata.GetSchemaResponse, error)
	// GetPermissions asks the tablet for its permissions
	GetPermissions(context.Context, *tabletmanagerdata.GetPermissionsRequest) (*tabletmanagerdata.GetPermissionsResponse, error)
	SetReadOnly(context.Context, *tabletmanagerdata.SetReadOnlyRequest) (*tabletmanagerdata.SetReadOnlyResponse, error)
	SetReadWrite(context.Context, *tabletmanagerdata.SetReadWriteRequest) (*tabletmanagerdata.SetReadWriteResponse, error)
	// ChangeType asks the remote tablet to change its type
	ChangeType(context.Context, *tabletmanagerdata.ChangeTypeRequest) (*tabletmanagerdata.ChangeTypeResponse, error)
	Scrap(context.Context, *tabletmanagerdata.ScrapRequest) (*tabletmanagerdata.ScrapResponse, error)
	RefreshState(context.Context, *tabletmanagerdata.RefreshStateRequest) (*tabletmanagerdata.RefreshStateResponse, error)
	RunHealthCheck(context.Context, *tabletmanagerdata.RunHealthCheckRequest) (*tabletmanagerdata.RunHealthCheckResponse, error)
	ReloadSchema(context.Context, *tabletmanagerdata.ReloadSchemaRequest) (*tabletmanagerdata.ReloadSchemaResponse, error)
	PreflightSchema(context.Context, *tabletmanagerdata.PreflightSchemaRequest) (*tabletmanagerdata.PreflightSchemaResponse, error)
	ApplySchema(context.Context, *tabletmanagerdata.ApplySchemaRequest) (*tabletmanagerdata.ApplySchemaResponse, error)
	ExecuteFetchAsDba(context.Context, *tabletmanagerdata.ExecuteFetchAsDbaRequest) (*tabletmanagerdata.ExecuteFetchAsDbaResponse, error)
	ExecuteFetchAsApp(context.Context, *tabletmanagerdata.ExecuteFetchAsAppRequest) (*tabletmanagerdata.ExecuteFetchAsAppResponse, error)
	// SlaveStatus returns the current slave status.
	SlaveStatus(context.Context, *tabletmanagerdata.SlaveStatusRequest) (*tabletmanagerdata.SlaveStatusResponse, error)
	// MasterPosition returns the current master position
	MasterPosition(context.Context, *tabletmanagerdata.MasterPositionRequest) (*tabletmanagerdata.MasterPositionResponse, error)
	// StopSlave makes mysql stop its replication
	StopSlave(context.Context, *tabletmanagerdata.StopSlaveRequest) (*tabletmanagerdata.StopSlaveResponse, error)
	// StopSlaveMinimum stops the mysql replication after it reaches
	// the provided minimum point
	StopSlaveMinimum(context.Context, *tabletmanagerdata.StopSlaveMinimumRequest) (*tabletmanagerdata.StopSlaveMinimumResponse, error)
	// StartSlave starts the mysql replication
	StartSlave(context.Context, *tabletmanagerdata.StartSlaveRequest) (*tabletmanagerdata.StartSlaveResponse, error)
	// TabletExternallyReparented tells a tablet that its underlying MySQL is
	// currently the master. It is only used in environments (tabletmanagerdata.such as Vitess+MoB)
	// in which MySQL is reparented by some agent external to Vitess, and then
	// that agent simply notifies Vitess.
	//
	// This call is idempotent with respect to a single target tablet.
	// However, the tablet assumes there is a cooling-off period following the
	// initial external reparent from A to B, before this call is repeated on any
	// tablet other than B. This assumption is configurable with the vttablet flag
	// "finalize_external_reparent_timeout".
	//
	// For more information, see the design doc at go/vt-fast-failover.
	TabletExternallyReparented(context.Context, *tabletmanagerdata.TabletExternallyReparentedRequest) (*tabletmanagerdata.TabletExternallyReparentedResponse, error)
	// TabletExternallyElected is an notification that may be sent in
	// anticipation of potentially later sending TabletExternallyReparented.
	// The tablet can use this extra lead time to prepare to react quickly if
	// TabletExternallyReparented does follow.
	//
	// This call is effectively a no-op if it is not followed by a call to
	// TabletExternallyReparented, so the external agent doing the reparent can
	// still change its mind.
	//
	// The agent does not need to wait for this call or cancel it before calling
	// TabletExternallyReparented if the external reparent operation finishes
	// before TabletExternallyElected returns.
	TabletExternallyElected(context.Context, *tabletmanagerdata.TabletExternallyElectedRequest) (*tabletmanagerdata.TabletExternallyElectedResponse, error)
	// GetSlaves asks for the list of mysql slaves
	GetSlaves(context.Context, *tabletmanagerdata.GetSlavesRequest) (*tabletmanagerdata.GetSlavesResponse, error)
	// WaitBlpPosition tells the remote tablet to wait until it reaches
	// the specified binolg player position
	WaitBlpPosition(context.Context, *tabletmanagerdata.WaitBlpPositionRequest) (*tabletmanagerdata.WaitBlpPositionResponse, error)
	// StopBlp asks the tablet to stop all its binlog players,
	// and returns the current position for all of them
	StopBlp(context.Context, *tabletmanagerdata.StopBlpRequest) (*tabletmanagerdata.StopBlpResponse, error)
	// StartBlp asks the tablet to restart its binlog players
	StartBlp(context.Context, *tabletmanagerdata.StartBlpRequest) (*tabletmanagerdata.StartBlpResponse, error)
	// RunBlpUntil asks the tablet to restart its binlog players
	RunBlpUntil(context.Context, *tabletmanagerdata.RunBlpUntilRequest) (*tabletmanagerdata.RunBlpUntilResponse, error)
	// ResetReplication makes the target not replicating
	ResetReplication(context.Context, *tabletmanagerdata.ResetReplicationRequest) (*tabletmanagerdata.ResetReplicationResponse, error)
	// InitMaster initializes the tablet as a master
	InitMaster(context.Context, *tabletmanagerdata.InitMasterRequest) (*tabletmanagerdata.InitMasterResponse, error)
	// PopulateReparentJournal tells the tablet to add an entry to its
	// reparent journal
	PopulateReparentJournal(context.Context, *tabletmanagerdata.PopulateReparentJournalRequest) (*tabletmanagerdata.PopulateReparentJournalResponse, error)
	// InitSlave tells the tablet to reparent to the master unconditionnally
	InitSlave(context.Context, *tabletmanagerdata.InitSlaveRequest) (*tabletmanagerdata.InitSlaveResponse, error)
	// DemoteMaster tells the soon-to-be-former master it's gonna change
	DemoteMaster(context.Context, *tabletmanagerdata.DemoteMasterRequest) (*tabletmanagerdata.DemoteMasterResponse, error)
	// PromoteSlaveWhenCaughtUp tells the remote tablet to catch up,
	// and then be the master
	PromoteSlaveWhenCaughtUp(context.Context, *tabletmanagerdata.PromoteSlaveWhenCaughtUpRequest) (*tabletmanagerdata.PromoteSlaveWhenCaughtUpResponse, error)
	// SlaveWasPromoted tells the remote tablet it is now the master
	SlaveWasPromoted(context.Context, *tabletmanagerdata.SlaveWasPromotedRequest) (*tabletmanagerdata.SlaveWasPromotedResponse, error)
	// SetMaster tells the slave to reparent
	SetMaster(context.Context, *tabletmanagerdata.SetMasterRequest) (*tabletmanagerdata.SetMasterResponse, error)
	// SlaveWasRestarted tells the remote tablet its master has changed
	SlaveWasRestarted(context.Context, *tabletmanagerdata.SlaveWasRestartedRequest) (*tabletmanagerdata.SlaveWasRestartedResponse, error)
	// StopReplicationAndGetStatus stops MySQL replication, and returns the
	// replication status
	StopReplicationAndGetStatus(context.Context, *tabletmanagerdata.StopReplicationAndGetStatusRequest) (*tabletmanagerdata.StopReplicationAndGetStatusResponse, error)
	// PromoteSlave makes the slave the new master
	PromoteSlave(context.Context, *tabletmanagerdata.PromoteSlaveRequest) (*tabletmanagerdata.PromoteSlaveResponse, error)
	Backup(*tabletmanagerdata.BackupRequest, TabletManager_BackupServer) error
}

func RegisterTabletManagerServer(s *grpc.Server, srv TabletManagerServer) {
	s.RegisterService(&_TabletManager_serviceDesc, srv)
}

func _TabletManager_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.PingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).Ping(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_Sleep_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.SleepRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).Sleep(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_ExecuteHook_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.ExecuteHookRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).ExecuteHook(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_GetSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.GetSchemaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).GetSchema(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_GetPermissions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.GetPermissionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).GetPermissions(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_SetReadOnly_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.SetReadOnlyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).SetReadOnly(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_SetReadWrite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.SetReadWriteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).SetReadWrite(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_ChangeType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.ChangeTypeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).ChangeType(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_Scrap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.ScrapRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).Scrap(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_RefreshState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.RefreshStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).RefreshState(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_RunHealthCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.RunHealthCheckRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).RunHealthCheck(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_ReloadSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.ReloadSchemaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).ReloadSchema(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_PreflightSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.PreflightSchemaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).PreflightSchema(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_ApplySchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.ApplySchemaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).ApplySchema(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_ExecuteFetchAsDba_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.ExecuteFetchAsDbaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).ExecuteFetchAsDba(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_ExecuteFetchAsApp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.ExecuteFetchAsAppRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).ExecuteFetchAsApp(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_SlaveStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.SlaveStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).SlaveStatus(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_MasterPosition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.MasterPositionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).MasterPosition(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_StopSlave_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.StopSlaveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).StopSlave(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_StopSlaveMinimum_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.StopSlaveMinimumRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).StopSlaveMinimum(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_StartSlave_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.StartSlaveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).StartSlave(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_TabletExternallyReparented_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.TabletExternallyReparentedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).TabletExternallyReparented(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_TabletExternallyElected_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.TabletExternallyElectedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).TabletExternallyElected(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_GetSlaves_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.GetSlavesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).GetSlaves(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_WaitBlpPosition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.WaitBlpPositionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).WaitBlpPosition(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_StopBlp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.StopBlpRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).StopBlp(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_StartBlp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.StartBlpRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).StartBlp(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_RunBlpUntil_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.RunBlpUntilRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).RunBlpUntil(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_ResetReplication_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.ResetReplicationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).ResetReplication(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_InitMaster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.InitMasterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).InitMaster(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_PopulateReparentJournal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.PopulateReparentJournalRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).PopulateReparentJournal(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_InitSlave_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.InitSlaveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).InitSlave(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_DemoteMaster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.DemoteMasterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).DemoteMaster(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_PromoteSlaveWhenCaughtUp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.PromoteSlaveWhenCaughtUpRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).PromoteSlaveWhenCaughtUp(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_SlaveWasPromoted_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.SlaveWasPromotedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).SlaveWasPromoted(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_SetMaster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.SetMasterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).SetMaster(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_SlaveWasRestarted_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.SlaveWasRestartedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).SlaveWasRestarted(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_StopReplicationAndGetStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.StopReplicationAndGetStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).StopReplicationAndGetStatus(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_PromoteSlave_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(tabletmanagerdata.PromoteSlaveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(TabletManagerServer).PromoteSlave(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _TabletManager_Backup_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(tabletmanagerdata.BackupRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TabletManagerServer).Backup(m, &tabletManagerBackupServer{stream})
}

type TabletManager_BackupServer interface {
	Send(*tabletmanagerdata.BackupResponse) error
	grpc.ServerStream
}

type tabletManagerBackupServer struct {
	grpc.ServerStream
}

func (x *tabletManagerBackupServer) Send(m *tabletmanagerdata.BackupResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _TabletManager_serviceDesc = grpc.ServiceDesc{
	ServiceName: "tabletmanagerservice.TabletManager",
	HandlerType: (*TabletManagerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _TabletManager_Ping_Handler,
		},
		{
			MethodName: "Sleep",
			Handler:    _TabletManager_Sleep_Handler,
		},
		{
			MethodName: "ExecuteHook",
			Handler:    _TabletManager_ExecuteHook_Handler,
		},
		{
			MethodName: "GetSchema",
			Handler:    _TabletManager_GetSchema_Handler,
		},
		{
			MethodName: "GetPermissions",
			Handler:    _TabletManager_GetPermissions_Handler,
		},
		{
			MethodName: "SetReadOnly",
			Handler:    _TabletManager_SetReadOnly_Handler,
		},
		{
			MethodName: "SetReadWrite",
			Handler:    _TabletManager_SetReadWrite_Handler,
		},
		{
			MethodName: "ChangeType",
			Handler:    _TabletManager_ChangeType_Handler,
		},
		{
			MethodName: "Scrap",
			Handler:    _TabletManager_Scrap_Handler,
		},
		{
			MethodName: "RefreshState",
			Handler:    _TabletManager_RefreshState_Handler,
		},
		{
			MethodName: "RunHealthCheck",
			Handler:    _TabletManager_RunHealthCheck_Handler,
		},
		{
			MethodName: "ReloadSchema",
			Handler:    _TabletManager_ReloadSchema_Handler,
		},
		{
			MethodName: "PreflightSchema",
			Handler:    _TabletManager_PreflightSchema_Handler,
		},
		{
			MethodName: "ApplySchema",
			Handler:    _TabletManager_ApplySchema_Handler,
		},
		{
			MethodName: "ExecuteFetchAsDba",
			Handler:    _TabletManager_ExecuteFetchAsDba_Handler,
		},
		{
			MethodName: "ExecuteFetchAsApp",
			Handler:    _TabletManager_ExecuteFetchAsApp_Handler,
		},
		{
			MethodName: "SlaveStatus",
			Handler:    _TabletManager_SlaveStatus_Handler,
		},
		{
			MethodName: "MasterPosition",
			Handler:    _TabletManager_MasterPosition_Handler,
		},
		{
			MethodName: "StopSlave",
			Handler:    _TabletManager_StopSlave_Handler,
		},
		{
			MethodName: "StopSlaveMinimum",
			Handler:    _TabletManager_StopSlaveMinimum_Handler,
		},
		{
			MethodName: "StartSlave",
			Handler:    _TabletManager_StartSlave_Handler,
		},
		{
			MethodName: "TabletExternallyReparented",
			Handler:    _TabletManager_TabletExternallyReparented_Handler,
		},
		{
			MethodName: "TabletExternallyElected",
			Handler:    _TabletManager_TabletExternallyElected_Handler,
		},
		{
			MethodName: "GetSlaves",
			Handler:    _TabletManager_GetSlaves_Handler,
		},
		{
			MethodName: "WaitBlpPosition",
			Handler:    _TabletManager_WaitBlpPosition_Handler,
		},
		{
			MethodName: "StopBlp",
			Handler:    _TabletManager_StopBlp_Handler,
		},
		{
			MethodName: "StartBlp",
			Handler:    _TabletManager_StartBlp_Handler,
		},
		{
			MethodName: "RunBlpUntil",
			Handler:    _TabletManager_RunBlpUntil_Handler,
		},
		{
			MethodName: "ResetReplication",
			Handler:    _TabletManager_ResetReplication_Handler,
		},
		{
			MethodName: "InitMaster",
			Handler:    _TabletManager_InitMaster_Handler,
		},
		{
			MethodName: "PopulateReparentJournal",
			Handler:    _TabletManager_PopulateReparentJournal_Handler,
		},
		{
			MethodName: "InitSlave",
			Handler:    _TabletManager_InitSlave_Handler,
		},
		{
			MethodName: "DemoteMaster",
			Handler:    _TabletManager_DemoteMaster_Handler,
		},
		{
			MethodName: "PromoteSlaveWhenCaughtUp",
			Handler:    _TabletManager_PromoteSlaveWhenCaughtUp_Handler,
		},
		{
			MethodName: "SlaveWasPromoted",
			Handler:    _TabletManager_SlaveWasPromoted_Handler,
		},
		{
			MethodName: "SetMaster",
			Handler:    _TabletManager_SetMaster_Handler,
		},
		{
			MethodName: "SlaveWasRestarted",
			Handler:    _TabletManager_SlaveWasRestarted_Handler,
		},
		{
			MethodName: "StopReplicationAndGetStatus",
			Handler:    _TabletManager_StopReplicationAndGetStatus_Handler,
		},
		{
			MethodName: "PromoteSlave",
			Handler:    _TabletManager_PromoteSlave_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Backup",
			Handler:       _TabletManager_Backup_Handler,
			ServerStreams: true,
		},
	},
}