streamctl/pkg/streamd/grpc/go/streamd_grpc/streamd_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.

package streamd_grpc

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.
const _ = grpc.SupportPackageIsVersion7

// StreamDClient is the client API for StreamD 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 StreamDClient interface {
	Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingReply, error)
	SetLoggingLevel(ctx context.Context, in *SetLoggingLevelRequest, opts ...grpc.CallOption) (*SetLoggingLevelReply, error)
	GetLoggingLevel(ctx context.Context, in *GetLoggingLevelRequest, opts ...grpc.CallOption) (*GetLoggingLevelReply, error)
	GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigReply, error)
	SetConfig(ctx context.Context, in *SetConfigRequest, opts ...grpc.CallOption) (*SetConfigReply, error)
	SaveConfig(ctx context.Context, in *SaveConfigRequest, opts ...grpc.CallOption) (*SaveConfigReply, error)
	SubscribeToConfigChanges(ctx context.Context, in *SubscribeToConfigChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToConfigChangesClient, error)
	ResetCache(ctx context.Context, in *ResetCacheRequest, opts ...grpc.CallOption) (*ResetCacheReply, error)
	InitCache(ctx context.Context, in *InitCacheRequest, opts ...grpc.CallOption) (*InitCacheReply, error)
	StartStream(ctx context.Context, in *StartStreamRequest, opts ...grpc.CallOption) (*StartStreamReply, error)
	EndStream(ctx context.Context, in *EndStreamRequest, opts ...grpc.CallOption) (*EndStreamReply, error)
	GetStreamStatus(ctx context.Context, in *GetStreamStatusRequest, opts ...grpc.CallOption) (*GetStreamStatusReply, error)
	IsBackendEnabled(ctx context.Context, in *IsBackendEnabledRequest, opts ...grpc.CallOption) (*IsBackendEnabledReply, error)
	GetBackendInfo(ctx context.Context, in *GetBackendInfoRequest, opts ...grpc.CallOption) (*GetBackendInfoReply, error)
	SubscribeToStreamsChanges(ctx context.Context, in *SubscribeToStreamsChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToStreamsChangesClient, error)
	Restart(ctx context.Context, in *RestartRequest, opts ...grpc.CallOption) (*RestartReply, error)
	SetTitle(ctx context.Context, in *SetTitleRequest, opts ...grpc.CallOption) (*SetTitleReply, error)
	SetDescription(ctx context.Context, in *SetDescriptionRequest, opts ...grpc.CallOption) (*SetDescriptionReply, error)
	ApplyProfile(ctx context.Context, in *ApplyProfileRequest, opts ...grpc.CallOption) (*ApplyProfileReply, error)
	UpdateStream(ctx context.Context, in *UpdateStreamRequest, opts ...grpc.CallOption) (*UpdateStreamReply, error)
	GetVariable(ctx context.Context, in *GetVariableRequest, opts ...grpc.CallOption) (*GetVariableReply, error)
	GetVariableHash(ctx context.Context, in *GetVariableHashRequest, opts ...grpc.CallOption) (*GetVariableHashReply, error)
	SetVariable(ctx context.Context, in *SetVariableRequest, opts ...grpc.CallOption) (*SetVariableReply, error)
	EXPERIMENTAL_ReinitStreamControllers(ctx context.Context, in *EXPERIMENTAL_ReinitStreamControllersRequest, opts ...grpc.CallOption) (*EXPERIMENTAL_ReinitStreamControllersReply, error)
	OBSOLETE_FetchConfig(ctx context.Context, in *OBSOLETE_FetchConfigRequest, opts ...grpc.CallOption) (*OBSOLETE_FetchConfigReply, error)
	OBSOLETE_GitInfo(ctx context.Context, in *OBSOLETE_GetGitInfoRequest, opts ...grpc.CallOption) (*OBSOLETE_GetGitInfoReply, error)
	OBSOLETE_GitRelogin(ctx context.Context, in *OBSOLETE_GitReloginRequest, opts ...grpc.CallOption) (*OBSOLETE_GitReloginReply, error)
	SubscribeToOAuthRequests(ctx context.Context, in *SubscribeToOAuthRequestsRequest, opts ...grpc.CallOption) (StreamD_SubscribeToOAuthRequestsClient, error)
	SubmitOAuthCode(ctx context.Context, in *SubmitOAuthCodeRequest, opts ...grpc.CallOption) (*SubmitOAuthCodeReply, error)
	ListStreamServers(ctx context.Context, in *ListStreamServersRequest, opts ...grpc.CallOption) (*ListStreamServersReply, error)
	StartStreamServer(ctx context.Context, in *StartStreamServerRequest, opts ...grpc.CallOption) (*StartStreamServerReply, error)
	StopStreamServer(ctx context.Context, in *StopStreamServerRequest, opts ...grpc.CallOption) (*StopStreamServerReply, error)
	SubscribeToStreamServersChanges(ctx context.Context, in *SubscribeToStreamServersChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToStreamServersChangesClient, error)
	ListStreamDestinations(ctx context.Context, in *ListStreamDestinationsRequest, opts ...grpc.CallOption) (*ListStreamDestinationsReply, error)
	AddStreamDestination(ctx context.Context, in *AddStreamDestinationRequest, opts ...grpc.CallOption) (*AddStreamDestinationReply, error)
	UpdateStreamDestination(ctx context.Context, in *UpdateStreamDestinationRequest, opts ...grpc.CallOption) (*UpdateStreamDestinationReply, error)
	RemoveStreamDestination(ctx context.Context, in *RemoveStreamDestinationRequest, opts ...grpc.CallOption) (*RemoveStreamDestinationReply, error)
	SubscribeToStreamDestinationsChanges(ctx context.Context, in *SubscribeToStreamDestinationsChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToStreamDestinationsChangesClient, error)
	AddIncomingStream(ctx context.Context, in *AddIncomingStreamRequest, opts ...grpc.CallOption) (*AddIncomingStreamReply, error)
	RemoveIncomingStream(ctx context.Context, in *RemoveIncomingStreamRequest, opts ...grpc.CallOption) (*RemoveIncomingStreamReply, error)
	ListIncomingStreams(ctx context.Context, in *ListIncomingStreamsRequest, opts ...grpc.CallOption) (*ListIncomingStreamsReply, error)
	SubscribeToIncomingStreamsChanges(ctx context.Context, in *SubscribeToIncomingStreamsChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToIncomingStreamsChangesClient, error)
	ListStreamForwards(ctx context.Context, in *ListStreamForwardsRequest, opts ...grpc.CallOption) (*ListStreamForwardsReply, error)
	AddStreamForward(ctx context.Context, in *AddStreamForwardRequest, opts ...grpc.CallOption) (*AddStreamForwardReply, error)
	UpdateStreamForward(ctx context.Context, in *UpdateStreamForwardRequest, opts ...grpc.CallOption) (*UpdateStreamForwardReply, error)
	RemoveStreamForward(ctx context.Context, in *RemoveStreamForwardRequest, opts ...grpc.CallOption) (*RemoveStreamForwardReply, error)
	SubscribeToStreamForwardsChanges(ctx context.Context, in *SubscribeToStreamForwardsChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToStreamForwardsChangesClient, error)
	WaitForStreamPublisher(ctx context.Context, in *WaitForStreamPublisherRequest, opts ...grpc.CallOption) (StreamD_WaitForStreamPublisherClient, error)
	AddStreamPlayer(ctx context.Context, in *AddStreamPlayerRequest, opts ...grpc.CallOption) (*AddStreamPlayerReply, error)
	RemoveStreamPlayer(ctx context.Context, in *RemoveStreamPlayerRequest, opts ...grpc.CallOption) (*RemoveStreamPlayerReply, error)
	UpdateStreamPlayer(ctx context.Context, in *UpdateStreamPlayerRequest, opts ...grpc.CallOption) (*UpdateStreamPlayerReply, error)
	ListStreamPlayers(ctx context.Context, in *ListStreamPlayersRequest, opts ...grpc.CallOption) (*ListStreamPlayersReply, error)
	GetStreamPlayer(ctx context.Context, in *GetStreamPlayerRequest, opts ...grpc.CallOption) (*GetStreamPlayerReply, error)
	SubscribeToStreamPlayersChanges(ctx context.Context, in *SubscribeToStreamPlayersChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToStreamPlayersChangesClient, error)
	StreamPlayerOpen(ctx context.Context, in *StreamPlayerOpenRequest, opts ...grpc.CallOption) (*StreamPlayerOpenReply, error)
	StreamPlayerProcessTitle(ctx context.Context, in *StreamPlayerProcessTitleRequest, opts ...grpc.CallOption) (*StreamPlayerProcessTitleReply, error)
	StreamPlayerGetLink(ctx context.Context, in *StreamPlayerGetLinkRequest, opts ...grpc.CallOption) (*StreamPlayerGetLinkReply, error)
	StreamPlayerEndChan(ctx context.Context, in *StreamPlayerEndChanRequest, opts ...grpc.CallOption) (StreamD_StreamPlayerEndChanClient, error)
	StreamPlayerIsEnded(ctx context.Context, in *StreamPlayerIsEndedRequest, opts ...grpc.CallOption) (*StreamPlayerIsEndedReply, error)
	StreamPlayerGetPosition(ctx context.Context, in *StreamPlayerGetPositionRequest, opts ...grpc.CallOption) (*StreamPlayerGetPositionReply, error)
	StreamPlayerGetLength(ctx context.Context, in *StreamPlayerGetLengthRequest, opts ...grpc.CallOption) (*StreamPlayerGetLengthReply, error)
	StreamPlayerSetSpeed(ctx context.Context, in *StreamPlayerSetSpeedRequest, opts ...grpc.CallOption) (*StreamPlayerSetSpeedReply, error)
	StreamPlayerSetPause(ctx context.Context, in *StreamPlayerSetPauseRequest, opts ...grpc.CallOption) (*StreamPlayerSetPauseReply, error)
	StreamPlayerStop(ctx context.Context, in *StreamPlayerStopRequest, opts ...grpc.CallOption) (*StreamPlayerStopReply, error)
	StreamPlayerClose(ctx context.Context, in *StreamPlayerCloseRequest, opts ...grpc.CallOption) (*StreamPlayerCloseReply, error)
	AddTimer(ctx context.Context, in *AddTimerRequest, opts ...grpc.CallOption) (*AddTimerReply, error)
	RemoveTimer(ctx context.Context, in *RemoveTimerRequest, opts ...grpc.CallOption) (*RemoveTimerReply, error)
	ListTimers(ctx context.Context, in *ListTimersRequest, opts ...grpc.CallOption) (*ListTimersReply, error)
	ListTriggerRules(ctx context.Context, in *ListTriggerRulesRequest, opts ...grpc.CallOption) (*ListTriggerRulesReply, error)
	AddTriggerRule(ctx context.Context, in *AddTriggerRuleRequest, opts ...grpc.CallOption) (*AddTriggerRuleReply, error)
	RemoveTriggerRule(ctx context.Context, in *RemoveTriggerRuleRequest, opts ...grpc.CallOption) (*RemoveTriggerRuleReply, error)
	UpdateTriggerRule(ctx context.Context, in *UpdateTriggerRuleRequest, opts ...grpc.CallOption) (*UpdateTriggerRuleReply, error)
	SubmitEvent(ctx context.Context, in *SubmitEventRequest, opts ...grpc.CallOption) (*SubmitEventReply, error)
	SubscribeToChatMessages(ctx context.Context, in *SubscribeToChatMessagesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToChatMessagesClient, error)
	RemoveChatMessage(ctx context.Context, in *RemoveChatMessageRequest, opts ...grpc.CallOption) (*RemoveChatMessageReply, error)
	BanUser(ctx context.Context, in *BanUserRequest, opts ...grpc.CallOption) (*BanUserReply, error)
}

type streamDClient struct {
	cc grpc.ClientConnInterface
}

func NewStreamDClient(cc grpc.ClientConnInterface) StreamDClient {
	return &streamDClient{cc}
}

func (c *streamDClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingReply, error) {
	out := new(PingReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/Ping", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SetLoggingLevel(ctx context.Context, in *SetLoggingLevelRequest, opts ...grpc.CallOption) (*SetLoggingLevelReply, error) {
	out := new(SetLoggingLevelReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/SetLoggingLevel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) GetLoggingLevel(ctx context.Context, in *GetLoggingLevelRequest, opts ...grpc.CallOption) (*GetLoggingLevelReply, error) {
	out := new(GetLoggingLevelReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/GetLoggingLevel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigReply, error) {
	out := new(GetConfigReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/GetConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SetConfig(ctx context.Context, in *SetConfigRequest, opts ...grpc.CallOption) (*SetConfigReply, error) {
	out := new(SetConfigReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/SetConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SaveConfig(ctx context.Context, in *SaveConfigRequest, opts ...grpc.CallOption) (*SaveConfigReply, error) {
	out := new(SaveConfigReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/SaveConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SubscribeToConfigChanges(ctx context.Context, in *SubscribeToConfigChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToConfigChangesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StreamD_serviceDesc.Streams[0], "/streamd.StreamD/SubscribeToConfigChanges", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamDSubscribeToConfigChangesClient{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 StreamD_SubscribeToConfigChangesClient interface {
	Recv() (*ConfigChange, error)
	grpc.ClientStream
}

type streamDSubscribeToConfigChangesClient struct {
	grpc.ClientStream
}

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

func (c *streamDClient) ResetCache(ctx context.Context, in *ResetCacheRequest, opts ...grpc.CallOption) (*ResetCacheReply, error) {
	out := new(ResetCacheReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/ResetCache", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) InitCache(ctx context.Context, in *InitCacheRequest, opts ...grpc.CallOption) (*InitCacheReply, error) {
	out := new(InitCacheReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/InitCache", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StartStream(ctx context.Context, in *StartStreamRequest, opts ...grpc.CallOption) (*StartStreamReply, error) {
	out := new(StartStreamReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StartStream", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) EndStream(ctx context.Context, in *EndStreamRequest, opts ...grpc.CallOption) (*EndStreamReply, error) {
	out := new(EndStreamReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/EndStream", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) GetStreamStatus(ctx context.Context, in *GetStreamStatusRequest, opts ...grpc.CallOption) (*GetStreamStatusReply, error) {
	out := new(GetStreamStatusReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/GetStreamStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) IsBackendEnabled(ctx context.Context, in *IsBackendEnabledRequest, opts ...grpc.CallOption) (*IsBackendEnabledReply, error) {
	out := new(IsBackendEnabledReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/IsBackendEnabled", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) GetBackendInfo(ctx context.Context, in *GetBackendInfoRequest, opts ...grpc.CallOption) (*GetBackendInfoReply, error) {
	out := new(GetBackendInfoReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/GetBackendInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SubscribeToStreamsChanges(ctx context.Context, in *SubscribeToStreamsChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToStreamsChangesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StreamD_serviceDesc.Streams[1], "/streamd.StreamD/SubscribeToStreamsChanges", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamDSubscribeToStreamsChangesClient{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 StreamD_SubscribeToStreamsChangesClient interface {
	Recv() (*StreamsChange, error)
	grpc.ClientStream
}

type streamDSubscribeToStreamsChangesClient struct {
	grpc.ClientStream
}

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

func (c *streamDClient) Restart(ctx context.Context, in *RestartRequest, opts ...grpc.CallOption) (*RestartReply, error) {
	out := new(RestartReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/Restart", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SetTitle(ctx context.Context, in *SetTitleRequest, opts ...grpc.CallOption) (*SetTitleReply, error) {
	out := new(SetTitleReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/SetTitle", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SetDescription(ctx context.Context, in *SetDescriptionRequest, opts ...grpc.CallOption) (*SetDescriptionReply, error) {
	out := new(SetDescriptionReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/SetDescription", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) ApplyProfile(ctx context.Context, in *ApplyProfileRequest, opts ...grpc.CallOption) (*ApplyProfileReply, error) {
	out := new(ApplyProfileReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/ApplyProfile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) UpdateStream(ctx context.Context, in *UpdateStreamRequest, opts ...grpc.CallOption) (*UpdateStreamReply, error) {
	out := new(UpdateStreamReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/UpdateStream", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) GetVariable(ctx context.Context, in *GetVariableRequest, opts ...grpc.CallOption) (*GetVariableReply, error) {
	out := new(GetVariableReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/GetVariable", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) GetVariableHash(ctx context.Context, in *GetVariableHashRequest, opts ...grpc.CallOption) (*GetVariableHashReply, error) {
	out := new(GetVariableHashReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/GetVariableHash", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SetVariable(ctx context.Context, in *SetVariableRequest, opts ...grpc.CallOption) (*SetVariableReply, error) {
	out := new(SetVariableReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/SetVariable", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) EXPERIMENTAL_ReinitStreamControllers(ctx context.Context, in *EXPERIMENTAL_ReinitStreamControllersRequest, opts ...grpc.CallOption) (*EXPERIMENTAL_ReinitStreamControllersReply, error) {
	out := new(EXPERIMENTAL_ReinitStreamControllersReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/EXPERIMENTAL_ReinitStreamControllers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) OBSOLETE_FetchConfig(ctx context.Context, in *OBSOLETE_FetchConfigRequest, opts ...grpc.CallOption) (*OBSOLETE_FetchConfigReply, error) {
	out := new(OBSOLETE_FetchConfigReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/OBSOLETE_FetchConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) OBSOLETE_GitInfo(ctx context.Context, in *OBSOLETE_GetGitInfoRequest, opts ...grpc.CallOption) (*OBSOLETE_GetGitInfoReply, error) {
	out := new(OBSOLETE_GetGitInfoReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/OBSOLETE_GitInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) OBSOLETE_GitRelogin(ctx context.Context, in *OBSOLETE_GitReloginRequest, opts ...grpc.CallOption) (*OBSOLETE_GitReloginReply, error) {
	out := new(OBSOLETE_GitReloginReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/OBSOLETE_GitRelogin", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SubscribeToOAuthRequests(ctx context.Context, in *SubscribeToOAuthRequestsRequest, opts ...grpc.CallOption) (StreamD_SubscribeToOAuthRequestsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StreamD_serviceDesc.Streams[2], "/streamd.StreamD/SubscribeToOAuthRequests", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamDSubscribeToOAuthRequestsClient{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 StreamD_SubscribeToOAuthRequestsClient interface {
	Recv() (*OAuthRequest, error)
	grpc.ClientStream
}

type streamDSubscribeToOAuthRequestsClient struct {
	grpc.ClientStream
}

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

func (c *streamDClient) SubmitOAuthCode(ctx context.Context, in *SubmitOAuthCodeRequest, opts ...grpc.CallOption) (*SubmitOAuthCodeReply, error) {
	out := new(SubmitOAuthCodeReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/SubmitOAuthCode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) ListStreamServers(ctx context.Context, in *ListStreamServersRequest, opts ...grpc.CallOption) (*ListStreamServersReply, error) {
	out := new(ListStreamServersReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/ListStreamServers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StartStreamServer(ctx context.Context, in *StartStreamServerRequest, opts ...grpc.CallOption) (*StartStreamServerReply, error) {
	out := new(StartStreamServerReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StartStreamServer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StopStreamServer(ctx context.Context, in *StopStreamServerRequest, opts ...grpc.CallOption) (*StopStreamServerReply, error) {
	out := new(StopStreamServerReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StopStreamServer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SubscribeToStreamServersChanges(ctx context.Context, in *SubscribeToStreamServersChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToStreamServersChangesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StreamD_serviceDesc.Streams[3], "/streamd.StreamD/SubscribeToStreamServersChanges", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamDSubscribeToStreamServersChangesClient{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 StreamD_SubscribeToStreamServersChangesClient interface {
	Recv() (*StreamServersChange, error)
	grpc.ClientStream
}

type streamDSubscribeToStreamServersChangesClient struct {
	grpc.ClientStream
}

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

func (c *streamDClient) ListStreamDestinations(ctx context.Context, in *ListStreamDestinationsRequest, opts ...grpc.CallOption) (*ListStreamDestinationsReply, error) {
	out := new(ListStreamDestinationsReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/ListStreamDestinations", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) AddStreamDestination(ctx context.Context, in *AddStreamDestinationRequest, opts ...grpc.CallOption) (*AddStreamDestinationReply, error) {
	out := new(AddStreamDestinationReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/AddStreamDestination", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) UpdateStreamDestination(ctx context.Context, in *UpdateStreamDestinationRequest, opts ...grpc.CallOption) (*UpdateStreamDestinationReply, error) {
	out := new(UpdateStreamDestinationReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/UpdateStreamDestination", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) RemoveStreamDestination(ctx context.Context, in *RemoveStreamDestinationRequest, opts ...grpc.CallOption) (*RemoveStreamDestinationReply, error) {
	out := new(RemoveStreamDestinationReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/RemoveStreamDestination", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SubscribeToStreamDestinationsChanges(ctx context.Context, in *SubscribeToStreamDestinationsChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToStreamDestinationsChangesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StreamD_serviceDesc.Streams[4], "/streamd.StreamD/SubscribeToStreamDestinationsChanges", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamDSubscribeToStreamDestinationsChangesClient{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 StreamD_SubscribeToStreamDestinationsChangesClient interface {
	Recv() (*StreamDestinationsChange, error)
	grpc.ClientStream
}

type streamDSubscribeToStreamDestinationsChangesClient struct {
	grpc.ClientStream
}

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

func (c *streamDClient) AddIncomingStream(ctx context.Context, in *AddIncomingStreamRequest, opts ...grpc.CallOption) (*AddIncomingStreamReply, error) {
	out := new(AddIncomingStreamReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/AddIncomingStream", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) RemoveIncomingStream(ctx context.Context, in *RemoveIncomingStreamRequest, opts ...grpc.CallOption) (*RemoveIncomingStreamReply, error) {
	out := new(RemoveIncomingStreamReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/RemoveIncomingStream", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) ListIncomingStreams(ctx context.Context, in *ListIncomingStreamsRequest, opts ...grpc.CallOption) (*ListIncomingStreamsReply, error) {
	out := new(ListIncomingStreamsReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/ListIncomingStreams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SubscribeToIncomingStreamsChanges(ctx context.Context, in *SubscribeToIncomingStreamsChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToIncomingStreamsChangesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StreamD_serviceDesc.Streams[5], "/streamd.StreamD/SubscribeToIncomingStreamsChanges", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamDSubscribeToIncomingStreamsChangesClient{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 StreamD_SubscribeToIncomingStreamsChangesClient interface {
	Recv() (*IncomingStreamsChange, error)
	grpc.ClientStream
}

type streamDSubscribeToIncomingStreamsChangesClient struct {
	grpc.ClientStream
}

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

func (c *streamDClient) ListStreamForwards(ctx context.Context, in *ListStreamForwardsRequest, opts ...grpc.CallOption) (*ListStreamForwardsReply, error) {
	out := new(ListStreamForwardsReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/ListStreamForwards", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) AddStreamForward(ctx context.Context, in *AddStreamForwardRequest, opts ...grpc.CallOption) (*AddStreamForwardReply, error) {
	out := new(AddStreamForwardReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/AddStreamForward", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) UpdateStreamForward(ctx context.Context, in *UpdateStreamForwardRequest, opts ...grpc.CallOption) (*UpdateStreamForwardReply, error) {
	out := new(UpdateStreamForwardReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/UpdateStreamForward", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) RemoveStreamForward(ctx context.Context, in *RemoveStreamForwardRequest, opts ...grpc.CallOption) (*RemoveStreamForwardReply, error) {
	out := new(RemoveStreamForwardReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/RemoveStreamForward", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SubscribeToStreamForwardsChanges(ctx context.Context, in *SubscribeToStreamForwardsChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToStreamForwardsChangesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StreamD_serviceDesc.Streams[6], "/streamd.StreamD/SubscribeToStreamForwardsChanges", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamDSubscribeToStreamForwardsChangesClient{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 StreamD_SubscribeToStreamForwardsChangesClient interface {
	Recv() (*StreamForwardsChange, error)
	grpc.ClientStream
}

type streamDSubscribeToStreamForwardsChangesClient struct {
	grpc.ClientStream
}

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

func (c *streamDClient) WaitForStreamPublisher(ctx context.Context, in *WaitForStreamPublisherRequest, opts ...grpc.CallOption) (StreamD_WaitForStreamPublisherClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StreamD_serviceDesc.Streams[7], "/streamd.StreamD/WaitForStreamPublisher", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamDWaitForStreamPublisherClient{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 StreamD_WaitForStreamPublisherClient interface {
	Recv() (*StreamPublisher, error)
	grpc.ClientStream
}

type streamDWaitForStreamPublisherClient struct {
	grpc.ClientStream
}

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

func (c *streamDClient) AddStreamPlayer(ctx context.Context, in *AddStreamPlayerRequest, opts ...grpc.CallOption) (*AddStreamPlayerReply, error) {
	out := new(AddStreamPlayerReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/AddStreamPlayer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) RemoveStreamPlayer(ctx context.Context, in *RemoveStreamPlayerRequest, opts ...grpc.CallOption) (*RemoveStreamPlayerReply, error) {
	out := new(RemoveStreamPlayerReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/RemoveStreamPlayer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) UpdateStreamPlayer(ctx context.Context, in *UpdateStreamPlayerRequest, opts ...grpc.CallOption) (*UpdateStreamPlayerReply, error) {
	out := new(UpdateStreamPlayerReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/UpdateStreamPlayer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) ListStreamPlayers(ctx context.Context, in *ListStreamPlayersRequest, opts ...grpc.CallOption) (*ListStreamPlayersReply, error) {
	out := new(ListStreamPlayersReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/ListStreamPlayers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) GetStreamPlayer(ctx context.Context, in *GetStreamPlayerRequest, opts ...grpc.CallOption) (*GetStreamPlayerReply, error) {
	out := new(GetStreamPlayerReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/GetStreamPlayer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SubscribeToStreamPlayersChanges(ctx context.Context, in *SubscribeToStreamPlayersChangesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToStreamPlayersChangesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StreamD_serviceDesc.Streams[8], "/streamd.StreamD/SubscribeToStreamPlayersChanges", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamDSubscribeToStreamPlayersChangesClient{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 StreamD_SubscribeToStreamPlayersChangesClient interface {
	Recv() (*StreamPlayersChange, error)
	grpc.ClientStream
}

type streamDSubscribeToStreamPlayersChangesClient struct {
	grpc.ClientStream
}

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

func (c *streamDClient) StreamPlayerOpen(ctx context.Context, in *StreamPlayerOpenRequest, opts ...grpc.CallOption) (*StreamPlayerOpenReply, error) {
	out := new(StreamPlayerOpenReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StreamPlayerOpen", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StreamPlayerProcessTitle(ctx context.Context, in *StreamPlayerProcessTitleRequest, opts ...grpc.CallOption) (*StreamPlayerProcessTitleReply, error) {
	out := new(StreamPlayerProcessTitleReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StreamPlayerProcessTitle", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StreamPlayerGetLink(ctx context.Context, in *StreamPlayerGetLinkRequest, opts ...grpc.CallOption) (*StreamPlayerGetLinkReply, error) {
	out := new(StreamPlayerGetLinkReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StreamPlayerGetLink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StreamPlayerEndChan(ctx context.Context, in *StreamPlayerEndChanRequest, opts ...grpc.CallOption) (StreamD_StreamPlayerEndChanClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StreamD_serviceDesc.Streams[9], "/streamd.StreamD/StreamPlayerEndChan", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamDStreamPlayerEndChanClient{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 StreamD_StreamPlayerEndChanClient interface {
	Recv() (*StreamPlayerEndChanReply, error)
	grpc.ClientStream
}

type streamDStreamPlayerEndChanClient struct {
	grpc.ClientStream
}

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

func (c *streamDClient) StreamPlayerIsEnded(ctx context.Context, in *StreamPlayerIsEndedRequest, opts ...grpc.CallOption) (*StreamPlayerIsEndedReply, error) {
	out := new(StreamPlayerIsEndedReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StreamPlayerIsEnded", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StreamPlayerGetPosition(ctx context.Context, in *StreamPlayerGetPositionRequest, opts ...grpc.CallOption) (*StreamPlayerGetPositionReply, error) {
	out := new(StreamPlayerGetPositionReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StreamPlayerGetPosition", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StreamPlayerGetLength(ctx context.Context, in *StreamPlayerGetLengthRequest, opts ...grpc.CallOption) (*StreamPlayerGetLengthReply, error) {
	out := new(StreamPlayerGetLengthReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StreamPlayerGetLength", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StreamPlayerSetSpeed(ctx context.Context, in *StreamPlayerSetSpeedRequest, opts ...grpc.CallOption) (*StreamPlayerSetSpeedReply, error) {
	out := new(StreamPlayerSetSpeedReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StreamPlayerSetSpeed", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StreamPlayerSetPause(ctx context.Context, in *StreamPlayerSetPauseRequest, opts ...grpc.CallOption) (*StreamPlayerSetPauseReply, error) {
	out := new(StreamPlayerSetPauseReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StreamPlayerSetPause", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StreamPlayerStop(ctx context.Context, in *StreamPlayerStopRequest, opts ...grpc.CallOption) (*StreamPlayerStopReply, error) {
	out := new(StreamPlayerStopReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StreamPlayerStop", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) StreamPlayerClose(ctx context.Context, in *StreamPlayerCloseRequest, opts ...grpc.CallOption) (*StreamPlayerCloseReply, error) {
	out := new(StreamPlayerCloseReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/StreamPlayerClose", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) AddTimer(ctx context.Context, in *AddTimerRequest, opts ...grpc.CallOption) (*AddTimerReply, error) {
	out := new(AddTimerReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/AddTimer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) RemoveTimer(ctx context.Context, in *RemoveTimerRequest, opts ...grpc.CallOption) (*RemoveTimerReply, error) {
	out := new(RemoveTimerReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/RemoveTimer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) ListTimers(ctx context.Context, in *ListTimersRequest, opts ...grpc.CallOption) (*ListTimersReply, error) {
	out := new(ListTimersReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/ListTimers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) ListTriggerRules(ctx context.Context, in *ListTriggerRulesRequest, opts ...grpc.CallOption) (*ListTriggerRulesReply, error) {
	out := new(ListTriggerRulesReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/ListTriggerRules", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) AddTriggerRule(ctx context.Context, in *AddTriggerRuleRequest, opts ...grpc.CallOption) (*AddTriggerRuleReply, error) {
	out := new(AddTriggerRuleReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/AddTriggerRule", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) RemoveTriggerRule(ctx context.Context, in *RemoveTriggerRuleRequest, opts ...grpc.CallOption) (*RemoveTriggerRuleReply, error) {
	out := new(RemoveTriggerRuleReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/RemoveTriggerRule", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) UpdateTriggerRule(ctx context.Context, in *UpdateTriggerRuleRequest, opts ...grpc.CallOption) (*UpdateTriggerRuleReply, error) {
	out := new(UpdateTriggerRuleReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/UpdateTriggerRule", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SubmitEvent(ctx context.Context, in *SubmitEventRequest, opts ...grpc.CallOption) (*SubmitEventReply, error) {
	out := new(SubmitEventReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/SubmitEvent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) SubscribeToChatMessages(ctx context.Context, in *SubscribeToChatMessagesRequest, opts ...grpc.CallOption) (StreamD_SubscribeToChatMessagesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_StreamD_serviceDesc.Streams[10], "/streamd.StreamD/SubscribeToChatMessages", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamDSubscribeToChatMessagesClient{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 StreamD_SubscribeToChatMessagesClient interface {
	Recv() (*ChatMessage, error)
	grpc.ClientStream
}

type streamDSubscribeToChatMessagesClient struct {
	grpc.ClientStream
}

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

func (c *streamDClient) RemoveChatMessage(ctx context.Context, in *RemoveChatMessageRequest, opts ...grpc.CallOption) (*RemoveChatMessageReply, error) {
	out := new(RemoveChatMessageReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/RemoveChatMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamDClient) BanUser(ctx context.Context, in *BanUserRequest, opts ...grpc.CallOption) (*BanUserReply, error) {
	out := new(BanUserReply)
	err := c.cc.Invoke(ctx, "/streamd.StreamD/BanUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// StreamDServer is the server API for StreamD service.
// All implementations must embed UnimplementedStreamDServer
// for forward compatibility
type StreamDServer interface {
	Ping(context.Context, *PingRequest) (*PingReply, error)
	SetLoggingLevel(context.Context, *SetLoggingLevelRequest) (*SetLoggingLevelReply, error)
	GetLoggingLevel(context.Context, *GetLoggingLevelRequest) (*GetLoggingLevelReply, error)
	GetConfig(context.Context, *GetConfigRequest) (*GetConfigReply, error)
	SetConfig(context.Context, *SetConfigRequest) (*SetConfigReply, error)
	SaveConfig(context.Context, *SaveConfigRequest) (*SaveConfigReply, error)
	SubscribeToConfigChanges(*SubscribeToConfigChangesRequest, StreamD_SubscribeToConfigChangesServer) error
	ResetCache(context.Context, *ResetCacheRequest) (*ResetCacheReply, error)
	InitCache(context.Context, *InitCacheRequest) (*InitCacheReply, error)
	StartStream(context.Context, *StartStreamRequest) (*StartStreamReply, error)
	EndStream(context.Context, *EndStreamRequest) (*EndStreamReply, error)
	GetStreamStatus(context.Context, *GetStreamStatusRequest) (*GetStreamStatusReply, error)
	IsBackendEnabled(context.Context, *IsBackendEnabledRequest) (*IsBackendEnabledReply, error)
	GetBackendInfo(context.Context, *GetBackendInfoRequest) (*GetBackendInfoReply, error)
	SubscribeToStreamsChanges(*SubscribeToStreamsChangesRequest, StreamD_SubscribeToStreamsChangesServer) error
	Restart(context.Context, *RestartRequest) (*RestartReply, error)
	SetTitle(context.Context, *SetTitleRequest) (*SetTitleReply, error)
	SetDescription(context.Context, *SetDescriptionRequest) (*SetDescriptionReply, error)
	ApplyProfile(context.Context, *ApplyProfileRequest) (*ApplyProfileReply, error)
	UpdateStream(context.Context, *UpdateStreamRequest) (*UpdateStreamReply, error)
	GetVariable(context.Context, *GetVariableRequest) (*GetVariableReply, error)
	GetVariableHash(context.Context, *GetVariableHashRequest) (*GetVariableHashReply, error)
	SetVariable(context.Context, *SetVariableRequest) (*SetVariableReply, error)
	EXPERIMENTAL_ReinitStreamControllers(context.Context, *EXPERIMENTAL_ReinitStreamControllersRequest) (*EXPERIMENTAL_ReinitStreamControllersReply, error)
	OBSOLETE_FetchConfig(context.Context, *OBSOLETE_FetchConfigRequest) (*OBSOLETE_FetchConfigReply, error)
	OBSOLETE_GitInfo(context.Context, *OBSOLETE_GetGitInfoRequest) (*OBSOLETE_GetGitInfoReply, error)
	OBSOLETE_GitRelogin(context.Context, *OBSOLETE_GitReloginRequest) (*OBSOLETE_GitReloginReply, error)
	SubscribeToOAuthRequests(*SubscribeToOAuthRequestsRequest, StreamD_SubscribeToOAuthRequestsServer) error
	SubmitOAuthCode(context.Context, *SubmitOAuthCodeRequest) (*SubmitOAuthCodeReply, error)
	ListStreamServers(context.Context, *ListStreamServersRequest) (*ListStreamServersReply, error)
	StartStreamServer(context.Context, *StartStreamServerRequest) (*StartStreamServerReply, error)
	StopStreamServer(context.Context, *StopStreamServerRequest) (*StopStreamServerReply, error)
	SubscribeToStreamServersChanges(*SubscribeToStreamServersChangesRequest, StreamD_SubscribeToStreamServersChangesServer) error
	ListStreamDestinations(context.Context, *ListStreamDestinationsRequest) (*ListStreamDestinationsReply, error)
	AddStreamDestination(context.Context, *AddStreamDestinationRequest) (*AddStreamDestinationReply, error)
	UpdateStreamDestination(context.Context, *UpdateStreamDestinationRequest) (*UpdateStreamDestinationReply, error)
	RemoveStreamDestination(context.Context, *RemoveStreamDestinationRequest) (*RemoveStreamDestinationReply, error)
	SubscribeToStreamDestinationsChanges(*SubscribeToStreamDestinationsChangesRequest, StreamD_SubscribeToStreamDestinationsChangesServer) error
	AddIncomingStream(context.Context, *AddIncomingStreamRequest) (*AddIncomingStreamReply, error)
	RemoveIncomingStream(context.Context, *RemoveIncomingStreamRequest) (*RemoveIncomingStreamReply, error)
	ListIncomingStreams(context.Context, *ListIncomingStreamsRequest) (*ListIncomingStreamsReply, error)
	SubscribeToIncomingStreamsChanges(*SubscribeToIncomingStreamsChangesRequest, StreamD_SubscribeToIncomingStreamsChangesServer) error
	ListStreamForwards(context.Context, *ListStreamForwardsRequest) (*ListStreamForwardsReply, error)
	AddStreamForward(context.Context, *AddStreamForwardRequest) (*AddStreamForwardReply, error)
	UpdateStreamForward(context.Context, *UpdateStreamForwardRequest) (*UpdateStreamForwardReply, error)
	RemoveStreamForward(context.Context, *RemoveStreamForwardRequest) (*RemoveStreamForwardReply, error)
	SubscribeToStreamForwardsChanges(*SubscribeToStreamForwardsChangesRequest, StreamD_SubscribeToStreamForwardsChangesServer) error
	WaitForStreamPublisher(*WaitForStreamPublisherRequest, StreamD_WaitForStreamPublisherServer) error
	AddStreamPlayer(context.Context, *AddStreamPlayerRequest) (*AddStreamPlayerReply, error)
	RemoveStreamPlayer(context.Context, *RemoveStreamPlayerRequest) (*RemoveStreamPlayerReply, error)
	UpdateStreamPlayer(context.Context, *UpdateStreamPlayerRequest) (*UpdateStreamPlayerReply, error)
	ListStreamPlayers(context.Context, *ListStreamPlayersRequest) (*ListStreamPlayersReply, error)
	GetStreamPlayer(context.Context, *GetStreamPlayerRequest) (*GetStreamPlayerReply, error)
	SubscribeToStreamPlayersChanges(*SubscribeToStreamPlayersChangesRequest, StreamD_SubscribeToStreamPlayersChangesServer) error
	StreamPlayerOpen(context.Context, *StreamPlayerOpenRequest) (*StreamPlayerOpenReply, error)
	StreamPlayerProcessTitle(context.Context, *StreamPlayerProcessTitleRequest) (*StreamPlayerProcessTitleReply, error)
	StreamPlayerGetLink(context.Context, *StreamPlayerGetLinkRequest) (*StreamPlayerGetLinkReply, error)
	StreamPlayerEndChan(*StreamPlayerEndChanRequest, StreamD_StreamPlayerEndChanServer) error
	StreamPlayerIsEnded(context.Context, *StreamPlayerIsEndedRequest) (*StreamPlayerIsEndedReply, error)
	StreamPlayerGetPosition(context.Context, *StreamPlayerGetPositionRequest) (*StreamPlayerGetPositionReply, error)
	StreamPlayerGetLength(context.Context, *StreamPlayerGetLengthRequest) (*StreamPlayerGetLengthReply, error)
	StreamPlayerSetSpeed(context.Context, *StreamPlayerSetSpeedRequest) (*StreamPlayerSetSpeedReply, error)
	StreamPlayerSetPause(context.Context, *StreamPlayerSetPauseRequest) (*StreamPlayerSetPauseReply, error)
	StreamPlayerStop(context.Context, *StreamPlayerStopRequest) (*StreamPlayerStopReply, error)
	StreamPlayerClose(context.Context, *StreamPlayerCloseRequest) (*StreamPlayerCloseReply, error)
	AddTimer(context.Context, *AddTimerRequest) (*AddTimerReply, error)
	RemoveTimer(context.Context, *RemoveTimerRequest) (*RemoveTimerReply, error)
	ListTimers(context.Context, *ListTimersRequest) (*ListTimersReply, error)
	ListTriggerRules(context.Context, *ListTriggerRulesRequest) (*ListTriggerRulesReply, error)
	AddTriggerRule(context.Context, *AddTriggerRuleRequest) (*AddTriggerRuleReply, error)
	RemoveTriggerRule(context.Context, *RemoveTriggerRuleRequest) (*RemoveTriggerRuleReply, error)
	UpdateTriggerRule(context.Context, *UpdateTriggerRuleRequest) (*UpdateTriggerRuleReply, error)
	SubmitEvent(context.Context, *SubmitEventRequest) (*SubmitEventReply, error)
	SubscribeToChatMessages(*SubscribeToChatMessagesRequest, StreamD_SubscribeToChatMessagesServer) error
	RemoveChatMessage(context.Context, *RemoveChatMessageRequest) (*RemoveChatMessageReply, error)
	BanUser(context.Context, *BanUserRequest) (*BanUserReply, error)
	mustEmbedUnimplementedStreamDServer()
}

// UnimplementedStreamDServer must be embedded to have forward compatible implementations.
type UnimplementedStreamDServer struct {
}

func (UnimplementedStreamDServer) Ping(context.Context, *PingRequest) (*PingReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
func (UnimplementedStreamDServer) SetLoggingLevel(context.Context, *SetLoggingLevelRequest) (*SetLoggingLevelReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetLoggingLevel not implemented")
}
func (UnimplementedStreamDServer) GetLoggingLevel(context.Context, *GetLoggingLevelRequest) (*GetLoggingLevelReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLoggingLevel not implemented")
}
func (UnimplementedStreamDServer) GetConfig(context.Context, *GetConfigRequest) (*GetConfigReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetConfig not implemented")
}
func (UnimplementedStreamDServer) SetConfig(context.Context, *SetConfigRequest) (*SetConfigReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetConfig not implemented")
}
func (UnimplementedStreamDServer) SaveConfig(context.Context, *SaveConfigRequest) (*SaveConfigReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SaveConfig not implemented")
}
func (UnimplementedStreamDServer) SubscribeToConfigChanges(*SubscribeToConfigChangesRequest, StreamD_SubscribeToConfigChangesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeToConfigChanges not implemented")
}
func (UnimplementedStreamDServer) ResetCache(context.Context, *ResetCacheRequest) (*ResetCacheReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResetCache not implemented")
}
func (UnimplementedStreamDServer) InitCache(context.Context, *InitCacheRequest) (*InitCacheReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InitCache not implemented")
}
func (UnimplementedStreamDServer) StartStream(context.Context, *StartStreamRequest) (*StartStreamReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartStream not implemented")
}
func (UnimplementedStreamDServer) EndStream(context.Context, *EndStreamRequest) (*EndStreamReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EndStream not implemented")
}
func (UnimplementedStreamDServer) GetStreamStatus(context.Context, *GetStreamStatusRequest) (*GetStreamStatusReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStreamStatus not implemented")
}
func (UnimplementedStreamDServer) IsBackendEnabled(context.Context, *IsBackendEnabledRequest) (*IsBackendEnabledReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IsBackendEnabled not implemented")
}
func (UnimplementedStreamDServer) GetBackendInfo(context.Context, *GetBackendInfoRequest) (*GetBackendInfoReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBackendInfo not implemented")
}
func (UnimplementedStreamDServer) SubscribeToStreamsChanges(*SubscribeToStreamsChangesRequest, StreamD_SubscribeToStreamsChangesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeToStreamsChanges not implemented")
}
func (UnimplementedStreamDServer) Restart(context.Context, *RestartRequest) (*RestartReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Restart not implemented")
}
func (UnimplementedStreamDServer) SetTitle(context.Context, *SetTitleRequest) (*SetTitleReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetTitle not implemented")
}
func (UnimplementedStreamDServer) SetDescription(context.Context, *SetDescriptionRequest) (*SetDescriptionReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetDescription not implemented")
}
func (UnimplementedStreamDServer) ApplyProfile(context.Context, *ApplyProfileRequest) (*ApplyProfileReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ApplyProfile not implemented")
}
func (UnimplementedStreamDServer) UpdateStream(context.Context, *UpdateStreamRequest) (*UpdateStreamReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateStream not implemented")
}
func (UnimplementedStreamDServer) GetVariable(context.Context, *GetVariableRequest) (*GetVariableReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVariable not implemented")
}
func (UnimplementedStreamDServer) GetVariableHash(context.Context, *GetVariableHashRequest) (*GetVariableHashReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVariableHash not implemented")
}
func (UnimplementedStreamDServer) SetVariable(context.Context, *SetVariableRequest) (*SetVariableReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetVariable not implemented")
}
func (UnimplementedStreamDServer) EXPERIMENTAL_ReinitStreamControllers(context.Context, *EXPERIMENTAL_ReinitStreamControllersRequest) (*EXPERIMENTAL_ReinitStreamControllersReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EXPERIMENTAL_ReinitStreamControllers not implemented")
}
func (UnimplementedStreamDServer) OBSOLETE_FetchConfig(context.Context, *OBSOLETE_FetchConfigRequest) (*OBSOLETE_FetchConfigReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OBSOLETE_FetchConfig not implemented")
}
func (UnimplementedStreamDServer) OBSOLETE_GitInfo(context.Context, *OBSOLETE_GetGitInfoRequest) (*OBSOLETE_GetGitInfoReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OBSOLETE_GitInfo not implemented")
}
func (UnimplementedStreamDServer) OBSOLETE_GitRelogin(context.Context, *OBSOLETE_GitReloginRequest) (*OBSOLETE_GitReloginReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OBSOLETE_GitRelogin not implemented")
}
func (UnimplementedStreamDServer) SubscribeToOAuthRequests(*SubscribeToOAuthRequestsRequest, StreamD_SubscribeToOAuthRequestsServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeToOAuthRequests not implemented")
}
func (UnimplementedStreamDServer) SubmitOAuthCode(context.Context, *SubmitOAuthCodeRequest) (*SubmitOAuthCodeReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitOAuthCode not implemented")
}
func (UnimplementedStreamDServer) ListStreamServers(context.Context, *ListStreamServersRequest) (*ListStreamServersReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListStreamServers not implemented")
}
func (UnimplementedStreamDServer) StartStreamServer(context.Context, *StartStreamServerRequest) (*StartStreamServerReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartStreamServer not implemented")
}
func (UnimplementedStreamDServer) StopStreamServer(context.Context, *StopStreamServerRequest) (*StopStreamServerReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopStreamServer not implemented")
}
func (UnimplementedStreamDServer) SubscribeToStreamServersChanges(*SubscribeToStreamServersChangesRequest, StreamD_SubscribeToStreamServersChangesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeToStreamServersChanges not implemented")
}
func (UnimplementedStreamDServer) ListStreamDestinations(context.Context, *ListStreamDestinationsRequest) (*ListStreamDestinationsReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListStreamDestinations not implemented")
}
func (UnimplementedStreamDServer) AddStreamDestination(context.Context, *AddStreamDestinationRequest) (*AddStreamDestinationReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddStreamDestination not implemented")
}
func (UnimplementedStreamDServer) UpdateStreamDestination(context.Context, *UpdateStreamDestinationRequest) (*UpdateStreamDestinationReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateStreamDestination not implemented")
}
func (UnimplementedStreamDServer) RemoveStreamDestination(context.Context, *RemoveStreamDestinationRequest) (*RemoveStreamDestinationReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveStreamDestination not implemented")
}
func (UnimplementedStreamDServer) SubscribeToStreamDestinationsChanges(*SubscribeToStreamDestinationsChangesRequest, StreamD_SubscribeToStreamDestinationsChangesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeToStreamDestinationsChanges not implemented")
}
func (UnimplementedStreamDServer) AddIncomingStream(context.Context, *AddIncomingStreamRequest) (*AddIncomingStreamReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddIncomingStream not implemented")
}
func (UnimplementedStreamDServer) RemoveIncomingStream(context.Context, *RemoveIncomingStreamRequest) (*RemoveIncomingStreamReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveIncomingStream not implemented")
}
func (UnimplementedStreamDServer) ListIncomingStreams(context.Context, *ListIncomingStreamsRequest) (*ListIncomingStreamsReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListIncomingStreams not implemented")
}
func (UnimplementedStreamDServer) SubscribeToIncomingStreamsChanges(*SubscribeToIncomingStreamsChangesRequest, StreamD_SubscribeToIncomingStreamsChangesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeToIncomingStreamsChanges not implemented")
}
func (UnimplementedStreamDServer) ListStreamForwards(context.Context, *ListStreamForwardsRequest) (*ListStreamForwardsReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListStreamForwards not implemented")
}
func (UnimplementedStreamDServer) AddStreamForward(context.Context, *AddStreamForwardRequest) (*AddStreamForwardReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddStreamForward not implemented")
}
func (UnimplementedStreamDServer) UpdateStreamForward(context.Context, *UpdateStreamForwardRequest) (*UpdateStreamForwardReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateStreamForward not implemented")
}
func (UnimplementedStreamDServer) RemoveStreamForward(context.Context, *RemoveStreamForwardRequest) (*RemoveStreamForwardReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveStreamForward not implemented")
}
func (UnimplementedStreamDServer) SubscribeToStreamForwardsChanges(*SubscribeToStreamForwardsChangesRequest, StreamD_SubscribeToStreamForwardsChangesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeToStreamForwardsChanges not implemented")
}
func (UnimplementedStreamDServer) WaitForStreamPublisher(*WaitForStreamPublisherRequest, StreamD_WaitForStreamPublisherServer) error {
	return status.Errorf(codes.Unimplemented, "method WaitForStreamPublisher not implemented")
}
func (UnimplementedStreamDServer) AddStreamPlayer(context.Context, *AddStreamPlayerRequest) (*AddStreamPlayerReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddStreamPlayer not implemented")
}
func (UnimplementedStreamDServer) RemoveStreamPlayer(context.Context, *RemoveStreamPlayerRequest) (*RemoveStreamPlayerReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveStreamPlayer not implemented")
}
func (UnimplementedStreamDServer) UpdateStreamPlayer(context.Context, *UpdateStreamPlayerRequest) (*UpdateStreamPlayerReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateStreamPlayer not implemented")
}
func (UnimplementedStreamDServer) ListStreamPlayers(context.Context, *ListStreamPlayersRequest) (*ListStreamPlayersReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListStreamPlayers not implemented")
}
func (UnimplementedStreamDServer) GetStreamPlayer(context.Context, *GetStreamPlayerRequest) (*GetStreamPlayerReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStreamPlayer not implemented")
}
func (UnimplementedStreamDServer) SubscribeToStreamPlayersChanges(*SubscribeToStreamPlayersChangesRequest, StreamD_SubscribeToStreamPlayersChangesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeToStreamPlayersChanges not implemented")
}
func (UnimplementedStreamDServer) StreamPlayerOpen(context.Context, *StreamPlayerOpenRequest) (*StreamPlayerOpenReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StreamPlayerOpen not implemented")
}
func (UnimplementedStreamDServer) StreamPlayerProcessTitle(context.Context, *StreamPlayerProcessTitleRequest) (*StreamPlayerProcessTitleReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StreamPlayerProcessTitle not implemented")
}
func (UnimplementedStreamDServer) StreamPlayerGetLink(context.Context, *StreamPlayerGetLinkRequest) (*StreamPlayerGetLinkReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StreamPlayerGetLink not implemented")
}
func (UnimplementedStreamDServer) StreamPlayerEndChan(*StreamPlayerEndChanRequest, StreamD_StreamPlayerEndChanServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamPlayerEndChan not implemented")
}
func (UnimplementedStreamDServer) StreamPlayerIsEnded(context.Context, *StreamPlayerIsEndedRequest) (*StreamPlayerIsEndedReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StreamPlayerIsEnded not implemented")
}
func (UnimplementedStreamDServer) StreamPlayerGetPosition(context.Context, *StreamPlayerGetPositionRequest) (*StreamPlayerGetPositionReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StreamPlayerGetPosition not implemented")
}
func (UnimplementedStreamDServer) StreamPlayerGetLength(context.Context, *StreamPlayerGetLengthRequest) (*StreamPlayerGetLengthReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StreamPlayerGetLength not implemented")
}
func (UnimplementedStreamDServer) StreamPlayerSetSpeed(context.Context, *StreamPlayerSetSpeedRequest) (*StreamPlayerSetSpeedReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StreamPlayerSetSpeed not implemented")
}
func (UnimplementedStreamDServer) StreamPlayerSetPause(context.Context, *StreamPlayerSetPauseRequest) (*StreamPlayerSetPauseReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StreamPlayerSetPause not implemented")
}
func (UnimplementedStreamDServer) StreamPlayerStop(context.Context, *StreamPlayerStopRequest) (*StreamPlayerStopReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StreamPlayerStop not implemented")
}
func (UnimplementedStreamDServer) StreamPlayerClose(context.Context, *StreamPlayerCloseRequest) (*StreamPlayerCloseReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StreamPlayerClose not implemented")
}
func (UnimplementedStreamDServer) AddTimer(context.Context, *AddTimerRequest) (*AddTimerReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddTimer not implemented")
}
func (UnimplementedStreamDServer) RemoveTimer(context.Context, *RemoveTimerRequest) (*RemoveTimerReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveTimer not implemented")
}
func (UnimplementedStreamDServer) ListTimers(context.Context, *ListTimersRequest) (*ListTimersReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTimers not implemented")
}
func (UnimplementedStreamDServer) ListTriggerRules(context.Context, *ListTriggerRulesRequest) (*ListTriggerRulesReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTriggerRules not implemented")
}
func (UnimplementedStreamDServer) AddTriggerRule(context.Context, *AddTriggerRuleRequest) (*AddTriggerRuleReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddTriggerRule not implemented")
}
func (UnimplementedStreamDServer) RemoveTriggerRule(context.Context, *RemoveTriggerRuleRequest) (*RemoveTriggerRuleReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveTriggerRule not implemented")
}
func (UnimplementedStreamDServer) UpdateTriggerRule(context.Context, *UpdateTriggerRuleRequest) (*UpdateTriggerRuleReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateTriggerRule not implemented")
}
func (UnimplementedStreamDServer) SubmitEvent(context.Context, *SubmitEventRequest) (*SubmitEventReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitEvent not implemented")
}
func (UnimplementedStreamDServer) SubscribeToChatMessages(*SubscribeToChatMessagesRequest, StreamD_SubscribeToChatMessagesServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeToChatMessages not implemented")
}
func (UnimplementedStreamDServer) RemoveChatMessage(context.Context, *RemoveChatMessageRequest) (*RemoveChatMessageReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveChatMessage not implemented")
}
func (UnimplementedStreamDServer) BanUser(context.Context, *BanUserRequest) (*BanUserReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BanUser not implemented")
}
func (UnimplementedStreamDServer) mustEmbedUnimplementedStreamDServer() {}

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

func RegisterStreamDServer(s *grpc.Server, srv StreamDServer) {
	s.RegisterService(&_StreamD_serviceDesc, srv)
}

func _StreamD_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).Ping(ctx, req.(*PingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SetLoggingLevel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetLoggingLevelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).SetLoggingLevel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/SetLoggingLevel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).SetLoggingLevel(ctx, req.(*SetLoggingLevelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_GetLoggingLevel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLoggingLevelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).GetLoggingLevel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/GetLoggingLevel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).GetLoggingLevel(ctx, req.(*GetLoggingLevelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_GetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).GetConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/GetConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).GetConfig(ctx, req.(*GetConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).SetConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/SetConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).SetConfig(ctx, req.(*SetConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SaveConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SaveConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).SaveConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/SaveConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).SaveConfig(ctx, req.(*SaveConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SubscribeToConfigChanges_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeToConfigChangesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamDServer).SubscribeToConfigChanges(m, &streamDSubscribeToConfigChangesServer{stream})
}

type StreamD_SubscribeToConfigChangesServer interface {
	Send(*ConfigChange) error
	grpc.ServerStream
}

type streamDSubscribeToConfigChangesServer struct {
	grpc.ServerStream
}

func (x *streamDSubscribeToConfigChangesServer) Send(m *ConfigChange) error {
	return x.ServerStream.SendMsg(m)
}

func _StreamD_ResetCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResetCacheRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).ResetCache(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/ResetCache",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).ResetCache(ctx, req.(*ResetCacheRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_InitCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InitCacheRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).InitCache(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/InitCache",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).InitCache(ctx, req.(*InitCacheRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StartStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StartStream(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StartStream",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StartStream(ctx, req.(*StartStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_EndStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EndStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).EndStream(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/EndStream",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).EndStream(ctx, req.(*EndStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_GetStreamStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetStreamStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).GetStreamStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/GetStreamStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).GetStreamStatus(ctx, req.(*GetStreamStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_IsBackendEnabled_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IsBackendEnabledRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).IsBackendEnabled(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/IsBackendEnabled",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).IsBackendEnabled(ctx, req.(*IsBackendEnabledRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_GetBackendInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetBackendInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).GetBackendInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/GetBackendInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).GetBackendInfo(ctx, req.(*GetBackendInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SubscribeToStreamsChanges_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeToStreamsChangesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamDServer).SubscribeToStreamsChanges(m, &streamDSubscribeToStreamsChangesServer{stream})
}

type StreamD_SubscribeToStreamsChangesServer interface {
	Send(*StreamsChange) error
	grpc.ServerStream
}

type streamDSubscribeToStreamsChangesServer struct {
	grpc.ServerStream
}

func (x *streamDSubscribeToStreamsChangesServer) Send(m *StreamsChange) error {
	return x.ServerStream.SendMsg(m)
}

func _StreamD_Restart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RestartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).Restart(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/Restart",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).Restart(ctx, req.(*RestartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SetTitle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetTitleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).SetTitle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/SetTitle",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).SetTitle(ctx, req.(*SetTitleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SetDescription_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetDescriptionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).SetDescription(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/SetDescription",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).SetDescription(ctx, req.(*SetDescriptionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_ApplyProfile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyProfileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).ApplyProfile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/ApplyProfile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).ApplyProfile(ctx, req.(*ApplyProfileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_UpdateStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).UpdateStream(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/UpdateStream",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).UpdateStream(ctx, req.(*UpdateStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_GetVariable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetVariableRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).GetVariable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/GetVariable",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).GetVariable(ctx, req.(*GetVariableRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_GetVariableHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetVariableHashRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).GetVariableHash(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/GetVariableHash",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).GetVariableHash(ctx, req.(*GetVariableHashRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SetVariable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetVariableRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).SetVariable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/SetVariable",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).SetVariable(ctx, req.(*SetVariableRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_EXPERIMENTAL_ReinitStreamControllers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EXPERIMENTAL_ReinitStreamControllersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).EXPERIMENTAL_ReinitStreamControllers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/EXPERIMENTAL_ReinitStreamControllers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).EXPERIMENTAL_ReinitStreamControllers(ctx, req.(*EXPERIMENTAL_ReinitStreamControllersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_OBSOLETE_FetchConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OBSOLETE_FetchConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).OBSOLETE_FetchConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/OBSOLETE_FetchConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).OBSOLETE_FetchConfig(ctx, req.(*OBSOLETE_FetchConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_OBSOLETE_GitInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OBSOLETE_GetGitInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).OBSOLETE_GitInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/OBSOLETE_GitInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).OBSOLETE_GitInfo(ctx, req.(*OBSOLETE_GetGitInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_OBSOLETE_GitRelogin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OBSOLETE_GitReloginRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).OBSOLETE_GitRelogin(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/OBSOLETE_GitRelogin",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).OBSOLETE_GitRelogin(ctx, req.(*OBSOLETE_GitReloginRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SubscribeToOAuthRequests_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeToOAuthRequestsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamDServer).SubscribeToOAuthRequests(m, &streamDSubscribeToOAuthRequestsServer{stream})
}

type StreamD_SubscribeToOAuthRequestsServer interface {
	Send(*OAuthRequest) error
	grpc.ServerStream
}

type streamDSubscribeToOAuthRequestsServer struct {
	grpc.ServerStream
}

func (x *streamDSubscribeToOAuthRequestsServer) Send(m *OAuthRequest) error {
	return x.ServerStream.SendMsg(m)
}

func _StreamD_SubmitOAuthCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubmitOAuthCodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).SubmitOAuthCode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/SubmitOAuthCode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).SubmitOAuthCode(ctx, req.(*SubmitOAuthCodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_ListStreamServers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListStreamServersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).ListStreamServers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/ListStreamServers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).ListStreamServers(ctx, req.(*ListStreamServersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StartStreamServer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartStreamServerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StartStreamServer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StartStreamServer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StartStreamServer(ctx, req.(*StartStreamServerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StopStreamServer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StopStreamServerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StopStreamServer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StopStreamServer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StopStreamServer(ctx, req.(*StopStreamServerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SubscribeToStreamServersChanges_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeToStreamServersChangesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamDServer).SubscribeToStreamServersChanges(m, &streamDSubscribeToStreamServersChangesServer{stream})
}

type StreamD_SubscribeToStreamServersChangesServer interface {
	Send(*StreamServersChange) error
	grpc.ServerStream
}

type streamDSubscribeToStreamServersChangesServer struct {
	grpc.ServerStream
}

func (x *streamDSubscribeToStreamServersChangesServer) Send(m *StreamServersChange) error {
	return x.ServerStream.SendMsg(m)
}

func _StreamD_ListStreamDestinations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListStreamDestinationsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).ListStreamDestinations(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/ListStreamDestinations",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).ListStreamDestinations(ctx, req.(*ListStreamDestinationsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_AddStreamDestination_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddStreamDestinationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).AddStreamDestination(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/AddStreamDestination",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).AddStreamDestination(ctx, req.(*AddStreamDestinationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_UpdateStreamDestination_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateStreamDestinationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).UpdateStreamDestination(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/UpdateStreamDestination",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).UpdateStreamDestination(ctx, req.(*UpdateStreamDestinationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_RemoveStreamDestination_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveStreamDestinationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).RemoveStreamDestination(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/RemoveStreamDestination",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).RemoveStreamDestination(ctx, req.(*RemoveStreamDestinationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SubscribeToStreamDestinationsChanges_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeToStreamDestinationsChangesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamDServer).SubscribeToStreamDestinationsChanges(m, &streamDSubscribeToStreamDestinationsChangesServer{stream})
}

type StreamD_SubscribeToStreamDestinationsChangesServer interface {
	Send(*StreamDestinationsChange) error
	grpc.ServerStream
}

type streamDSubscribeToStreamDestinationsChangesServer struct {
	grpc.ServerStream
}

func (x *streamDSubscribeToStreamDestinationsChangesServer) Send(m *StreamDestinationsChange) error {
	return x.ServerStream.SendMsg(m)
}

func _StreamD_AddIncomingStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddIncomingStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).AddIncomingStream(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/AddIncomingStream",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).AddIncomingStream(ctx, req.(*AddIncomingStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_RemoveIncomingStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveIncomingStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).RemoveIncomingStream(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/RemoveIncomingStream",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).RemoveIncomingStream(ctx, req.(*RemoveIncomingStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_ListIncomingStreams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListIncomingStreamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).ListIncomingStreams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/ListIncomingStreams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).ListIncomingStreams(ctx, req.(*ListIncomingStreamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SubscribeToIncomingStreamsChanges_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeToIncomingStreamsChangesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamDServer).SubscribeToIncomingStreamsChanges(m, &streamDSubscribeToIncomingStreamsChangesServer{stream})
}

type StreamD_SubscribeToIncomingStreamsChangesServer interface {
	Send(*IncomingStreamsChange) error
	grpc.ServerStream
}

type streamDSubscribeToIncomingStreamsChangesServer struct {
	grpc.ServerStream
}

func (x *streamDSubscribeToIncomingStreamsChangesServer) Send(m *IncomingStreamsChange) error {
	return x.ServerStream.SendMsg(m)
}

func _StreamD_ListStreamForwards_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListStreamForwardsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).ListStreamForwards(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/ListStreamForwards",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).ListStreamForwards(ctx, req.(*ListStreamForwardsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_AddStreamForward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddStreamForwardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).AddStreamForward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/AddStreamForward",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).AddStreamForward(ctx, req.(*AddStreamForwardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_UpdateStreamForward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateStreamForwardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).UpdateStreamForward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/UpdateStreamForward",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).UpdateStreamForward(ctx, req.(*UpdateStreamForwardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_RemoveStreamForward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveStreamForwardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).RemoveStreamForward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/RemoveStreamForward",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).RemoveStreamForward(ctx, req.(*RemoveStreamForwardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SubscribeToStreamForwardsChanges_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeToStreamForwardsChangesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamDServer).SubscribeToStreamForwardsChanges(m, &streamDSubscribeToStreamForwardsChangesServer{stream})
}

type StreamD_SubscribeToStreamForwardsChangesServer interface {
	Send(*StreamForwardsChange) error
	grpc.ServerStream
}

type streamDSubscribeToStreamForwardsChangesServer struct {
	grpc.ServerStream
}

func (x *streamDSubscribeToStreamForwardsChangesServer) Send(m *StreamForwardsChange) error {
	return x.ServerStream.SendMsg(m)
}

func _StreamD_WaitForStreamPublisher_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WaitForStreamPublisherRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamDServer).WaitForStreamPublisher(m, &streamDWaitForStreamPublisherServer{stream})
}

type StreamD_WaitForStreamPublisherServer interface {
	Send(*StreamPublisher) error
	grpc.ServerStream
}

type streamDWaitForStreamPublisherServer struct {
	grpc.ServerStream
}

func (x *streamDWaitForStreamPublisherServer) Send(m *StreamPublisher) error {
	return x.ServerStream.SendMsg(m)
}

func _StreamD_AddStreamPlayer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddStreamPlayerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).AddStreamPlayer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/AddStreamPlayer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).AddStreamPlayer(ctx, req.(*AddStreamPlayerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_RemoveStreamPlayer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveStreamPlayerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).RemoveStreamPlayer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/RemoveStreamPlayer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).RemoveStreamPlayer(ctx, req.(*RemoveStreamPlayerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_UpdateStreamPlayer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateStreamPlayerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).UpdateStreamPlayer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/UpdateStreamPlayer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).UpdateStreamPlayer(ctx, req.(*UpdateStreamPlayerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_ListStreamPlayers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListStreamPlayersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).ListStreamPlayers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/ListStreamPlayers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).ListStreamPlayers(ctx, req.(*ListStreamPlayersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_GetStreamPlayer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetStreamPlayerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).GetStreamPlayer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/GetStreamPlayer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).GetStreamPlayer(ctx, req.(*GetStreamPlayerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SubscribeToStreamPlayersChanges_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeToStreamPlayersChangesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamDServer).SubscribeToStreamPlayersChanges(m, &streamDSubscribeToStreamPlayersChangesServer{stream})
}

type StreamD_SubscribeToStreamPlayersChangesServer interface {
	Send(*StreamPlayersChange) error
	grpc.ServerStream
}

type streamDSubscribeToStreamPlayersChangesServer struct {
	grpc.ServerStream
}

func (x *streamDSubscribeToStreamPlayersChangesServer) Send(m *StreamPlayersChange) error {
	return x.ServerStream.SendMsg(m)
}

func _StreamD_StreamPlayerOpen_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamPlayerOpenRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StreamPlayerOpen(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StreamPlayerOpen",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StreamPlayerOpen(ctx, req.(*StreamPlayerOpenRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StreamPlayerProcessTitle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamPlayerProcessTitleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StreamPlayerProcessTitle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StreamPlayerProcessTitle",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StreamPlayerProcessTitle(ctx, req.(*StreamPlayerProcessTitleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StreamPlayerGetLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamPlayerGetLinkRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StreamPlayerGetLink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StreamPlayerGetLink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StreamPlayerGetLink(ctx, req.(*StreamPlayerGetLinkRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StreamPlayerEndChan_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StreamPlayerEndChanRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamDServer).StreamPlayerEndChan(m, &streamDStreamPlayerEndChanServer{stream})
}

type StreamD_StreamPlayerEndChanServer interface {
	Send(*StreamPlayerEndChanReply) error
	grpc.ServerStream
}

type streamDStreamPlayerEndChanServer struct {
	grpc.ServerStream
}

func (x *streamDStreamPlayerEndChanServer) Send(m *StreamPlayerEndChanReply) error {
	return x.ServerStream.SendMsg(m)
}

func _StreamD_StreamPlayerIsEnded_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamPlayerIsEndedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StreamPlayerIsEnded(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StreamPlayerIsEnded",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StreamPlayerIsEnded(ctx, req.(*StreamPlayerIsEndedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StreamPlayerGetPosition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamPlayerGetPositionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StreamPlayerGetPosition(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StreamPlayerGetPosition",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StreamPlayerGetPosition(ctx, req.(*StreamPlayerGetPositionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StreamPlayerGetLength_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamPlayerGetLengthRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StreamPlayerGetLength(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StreamPlayerGetLength",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StreamPlayerGetLength(ctx, req.(*StreamPlayerGetLengthRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StreamPlayerSetSpeed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamPlayerSetSpeedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StreamPlayerSetSpeed(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StreamPlayerSetSpeed",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StreamPlayerSetSpeed(ctx, req.(*StreamPlayerSetSpeedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StreamPlayerSetPause_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamPlayerSetPauseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StreamPlayerSetPause(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StreamPlayerSetPause",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StreamPlayerSetPause(ctx, req.(*StreamPlayerSetPauseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StreamPlayerStop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamPlayerStopRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StreamPlayerStop(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StreamPlayerStop",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StreamPlayerStop(ctx, req.(*StreamPlayerStopRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_StreamPlayerClose_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamPlayerCloseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).StreamPlayerClose(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/StreamPlayerClose",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).StreamPlayerClose(ctx, req.(*StreamPlayerCloseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_AddTimer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddTimerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).AddTimer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/AddTimer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).AddTimer(ctx, req.(*AddTimerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_RemoveTimer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveTimerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).RemoveTimer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/RemoveTimer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).RemoveTimer(ctx, req.(*RemoveTimerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_ListTimers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTimersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).ListTimers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/ListTimers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).ListTimers(ctx, req.(*ListTimersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_ListTriggerRules_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTriggerRulesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).ListTriggerRules(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/ListTriggerRules",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).ListTriggerRules(ctx, req.(*ListTriggerRulesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_AddTriggerRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddTriggerRuleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).AddTriggerRule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/AddTriggerRule",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).AddTriggerRule(ctx, req.(*AddTriggerRuleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_RemoveTriggerRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveTriggerRuleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).RemoveTriggerRule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/RemoveTriggerRule",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).RemoveTriggerRule(ctx, req.(*RemoveTriggerRuleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_UpdateTriggerRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateTriggerRuleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).UpdateTriggerRule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/UpdateTriggerRule",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).UpdateTriggerRule(ctx, req.(*UpdateTriggerRuleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SubmitEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubmitEventRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).SubmitEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/SubmitEvent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).SubmitEvent(ctx, req.(*SubmitEventRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_SubscribeToChatMessages_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeToChatMessagesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamDServer).SubscribeToChatMessages(m, &streamDSubscribeToChatMessagesServer{stream})
}

type StreamD_SubscribeToChatMessagesServer interface {
	Send(*ChatMessage) error
	grpc.ServerStream
}

type streamDSubscribeToChatMessagesServer struct {
	grpc.ServerStream
}

func (x *streamDSubscribeToChatMessagesServer) Send(m *ChatMessage) error {
	return x.ServerStream.SendMsg(m)
}

func _StreamD_RemoveChatMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveChatMessageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).RemoveChatMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/RemoveChatMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).RemoveChatMessage(ctx, req.(*RemoveChatMessageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _StreamD_BanUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BanUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamDServer).BanUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/streamd.StreamD/BanUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamDServer).BanUser(ctx, req.(*BanUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _StreamD_serviceDesc = grpc.ServiceDesc{
	ServiceName: "streamd.StreamD",
	HandlerType: (*StreamDServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _StreamD_Ping_Handler,
		},
		{
			MethodName: "SetLoggingLevel",
			Handler:    _StreamD_SetLoggingLevel_Handler,
		},
		{
			MethodName: "GetLoggingLevel",
			Handler:    _StreamD_GetLoggingLevel_Handler,
		},
		{
			MethodName: "GetConfig",
			Handler:    _StreamD_GetConfig_Handler,
		},
		{
			MethodName: "SetConfig",
			Handler:    _StreamD_SetConfig_Handler,
		},
		{
			MethodName: "SaveConfig",
			Handler:    _StreamD_SaveConfig_Handler,
		},
		{
			MethodName: "ResetCache",
			Handler:    _StreamD_ResetCache_Handler,
		},
		{
			MethodName: "InitCache",
			Handler:    _StreamD_InitCache_Handler,
		},
		{
			MethodName: "StartStream",
			Handler:    _StreamD_StartStream_Handler,
		},
		{
			MethodName: "EndStream",
			Handler:    _StreamD_EndStream_Handler,
		},
		{
			MethodName: "GetStreamStatus",
			Handler:    _StreamD_GetStreamStatus_Handler,
		},
		{
			MethodName: "IsBackendEnabled",
			Handler:    _StreamD_IsBackendEnabled_Handler,
		},
		{
			MethodName: "GetBackendInfo",
			Handler:    _StreamD_GetBackendInfo_Handler,
		},
		{
			MethodName: "Restart",
			Handler:    _StreamD_Restart_Handler,
		},
		{
			MethodName: "SetTitle",
			Handler:    _StreamD_SetTitle_Handler,
		},
		{
			MethodName: "SetDescription",
			Handler:    _StreamD_SetDescription_Handler,
		},
		{
			MethodName: "ApplyProfile",
			Handler:    _StreamD_ApplyProfile_Handler,
		},
		{
			MethodName: "UpdateStream",
			Handler:    _StreamD_UpdateStream_Handler,
		},
		{
			MethodName: "GetVariable",
			Handler:    _StreamD_GetVariable_Handler,
		},
		{
			MethodName: "GetVariableHash",
			Handler:    _StreamD_GetVariableHash_Handler,
		},
		{
			MethodName: "SetVariable",
			Handler:    _StreamD_SetVariable_Handler,
		},
		{
			MethodName: "EXPERIMENTAL_ReinitStreamControllers",
			Handler:    _StreamD_EXPERIMENTAL_ReinitStreamControllers_Handler,
		},
		{
			MethodName: "OBSOLETE_FetchConfig",
			Handler:    _StreamD_OBSOLETE_FetchConfig_Handler,
		},
		{
			MethodName: "OBSOLETE_GitInfo",
			Handler:    _StreamD_OBSOLETE_GitInfo_Handler,
		},
		{
			MethodName: "OBSOLETE_GitRelogin",
			Handler:    _StreamD_OBSOLETE_GitRelogin_Handler,
		},
		{
			MethodName: "SubmitOAuthCode",
			Handler:    _StreamD_SubmitOAuthCode_Handler,
		},
		{
			MethodName: "ListStreamServers",
			Handler:    _StreamD_ListStreamServers_Handler,
		},
		{
			MethodName: "StartStreamServer",
			Handler:    _StreamD_StartStreamServer_Handler,
		},
		{
			MethodName: "StopStreamServer",
			Handler:    _StreamD_StopStreamServer_Handler,
		},
		{
			MethodName: "ListStreamDestinations",
			Handler:    _StreamD_ListStreamDestinations_Handler,
		},
		{
			MethodName: "AddStreamDestination",
			Handler:    _StreamD_AddStreamDestination_Handler,
		},
		{
			MethodName: "UpdateStreamDestination",
			Handler:    _StreamD_UpdateStreamDestination_Handler,
		},
		{
			MethodName: "RemoveStreamDestination",
			Handler:    _StreamD_RemoveStreamDestination_Handler,
		},
		{
			MethodName: "AddIncomingStream",
			Handler:    _StreamD_AddIncomingStream_Handler,
		},
		{
			MethodName: "RemoveIncomingStream",
			Handler:    _StreamD_RemoveIncomingStream_Handler,
		},
		{
			MethodName: "ListIncomingStreams",
			Handler:    _StreamD_ListIncomingStreams_Handler,
		},
		{
			MethodName: "ListStreamForwards",
			Handler:    _StreamD_ListStreamForwards_Handler,
		},
		{
			MethodName: "AddStreamForward",
			Handler:    _StreamD_AddStreamForward_Handler,
		},
		{
			MethodName: "UpdateStreamForward",
			Handler:    _StreamD_UpdateStreamForward_Handler,
		},
		{
			MethodName: "RemoveStreamForward",
			Handler:    _StreamD_RemoveStreamForward_Handler,
		},
		{
			MethodName: "AddStreamPlayer",
			Handler:    _StreamD_AddStreamPlayer_Handler,
		},
		{
			MethodName: "RemoveStreamPlayer",
			Handler:    _StreamD_RemoveStreamPlayer_Handler,
		},
		{
			MethodName: "UpdateStreamPlayer",
			Handler:    _StreamD_UpdateStreamPlayer_Handler,
		},
		{
			MethodName: "ListStreamPlayers",
			Handler:    _StreamD_ListStreamPlayers_Handler,
		},
		{
			MethodName: "GetStreamPlayer",
			Handler:    _StreamD_GetStreamPlayer_Handler,
		},
		{
			MethodName: "StreamPlayerOpen",
			Handler:    _StreamD_StreamPlayerOpen_Handler,
		},
		{
			MethodName: "StreamPlayerProcessTitle",
			Handler:    _StreamD_StreamPlayerProcessTitle_Handler,
		},
		{
			MethodName: "StreamPlayerGetLink",
			Handler:    _StreamD_StreamPlayerGetLink_Handler,
		},
		{
			MethodName: "StreamPlayerIsEnded",
			Handler:    _StreamD_StreamPlayerIsEnded_Handler,
		},
		{
			MethodName: "StreamPlayerGetPosition",
			Handler:    _StreamD_StreamPlayerGetPosition_Handler,
		},
		{
			MethodName: "StreamPlayerGetLength",
			Handler:    _StreamD_StreamPlayerGetLength_Handler,
		},
		{
			MethodName: "StreamPlayerSetSpeed",
			Handler:    _StreamD_StreamPlayerSetSpeed_Handler,
		},
		{
			MethodName: "StreamPlayerSetPause",
			Handler:    _StreamD_StreamPlayerSetPause_Handler,
		},
		{
			MethodName: "StreamPlayerStop",
			Handler:    _StreamD_StreamPlayerStop_Handler,
		},
		{
			MethodName: "StreamPlayerClose",
			Handler:    _StreamD_StreamPlayerClose_Handler,
		},
		{
			MethodName: "AddTimer",
			Handler:    _StreamD_AddTimer_Handler,
		},
		{
			MethodName: "RemoveTimer",
			Handler:    _StreamD_RemoveTimer_Handler,
		},
		{
			MethodName: "ListTimers",
			Handler:    _StreamD_ListTimers_Handler,
		},
		{
			MethodName: "ListTriggerRules",
			Handler:    _StreamD_ListTriggerRules_Handler,
		},
		{
			MethodName: "AddTriggerRule",
			Handler:    _StreamD_AddTriggerRule_Handler,
		},
		{
			MethodName: "RemoveTriggerRule",
			Handler:    _StreamD_RemoveTriggerRule_Handler,
		},
		{
			MethodName: "UpdateTriggerRule",
			Handler:    _StreamD_UpdateTriggerRule_Handler,
		},
		{
			MethodName: "SubmitEvent",
			Handler:    _StreamD_SubmitEvent_Handler,
		},
		{
			MethodName: "RemoveChatMessage",
			Handler:    _StreamD_RemoveChatMessage_Handler,
		},
		{
			MethodName: "BanUser",
			Handler:    _StreamD_BanUser_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SubscribeToConfigChanges",
			Handler:       _StreamD_SubscribeToConfigChanges_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeToStreamsChanges",
			Handler:       _StreamD_SubscribeToStreamsChanges_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeToOAuthRequests",
			Handler:       _StreamD_SubscribeToOAuthRequests_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeToStreamServersChanges",
			Handler:       _StreamD_SubscribeToStreamServersChanges_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeToStreamDestinationsChanges",
			Handler:       _StreamD_SubscribeToStreamDestinationsChanges_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeToIncomingStreamsChanges",
			Handler:       _StreamD_SubscribeToIncomingStreamsChanges_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeToStreamForwardsChanges",
			Handler:       _StreamD_SubscribeToStreamForwardsChanges_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WaitForStreamPublisher",
			Handler:       _StreamD_WaitForStreamPublisher_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeToStreamPlayersChanges",
			Handler:       _StreamD_SubscribeToStreamPlayersChanges_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StreamPlayerEndChan",
			Handler:       _StreamD_StreamPlayerEndChan_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeToChatMessages",
			Handler:       _StreamD_SubscribeToChatMessages_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "streamd.proto",
}