zzz_clients.go

// Code generated by generate/main.go. DO NOT EDIT.
// source: api/api.proto

package iterm2

import (
	"errors"
	"github.com/tjamet/goterm2/api"
)

func (I *ITerm2) Activate(r *api.ActivateRequest) (*api.ActivateResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_ActivateRequest{
			ActivateRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending ActivateRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetActivateResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for Activate no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) Close(r *api.CloseRequest) (*api.CloseResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_CloseRequest{
			CloseRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending CloseRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetCloseResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for Close no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) ColorPreset(r *api.ColorPresetRequest) (*api.ColorPresetResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_ColorPresetRequest{
			ColorPresetRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending ColorPresetRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetColorPresetResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for ColorPreset no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) CreateTab(r *api.CreateTabRequest) (*api.CreateTabResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_CreateTabRequest{
			CreateTabRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending CreateTabRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetCreateTabResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for CreateTab no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) Focus(r *api.FocusRequest) (*api.FocusResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_FocusRequest{
			FocusRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending FocusRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetFocusResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for Focus no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) GetBroadcastDomains(r *api.GetBroadcastDomainsRequest) (*api.GetBroadcastDomainsResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_GetBroadcastDomainsRequest{
			GetBroadcastDomainsRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending GetBroadcastDomainsRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetGetBroadcastDomainsResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for GetBroadcastDomains no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) GetBuffer(r *api.GetBufferRequest) (*api.GetBufferResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_GetBufferRequest{
			GetBufferRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending GetBufferRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetGetBufferResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for GetBuffer no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) GetProfileProperty(r *api.GetProfilePropertyRequest) (*api.GetProfilePropertyResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_GetProfilePropertyRequest{
			GetProfilePropertyRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending GetProfilePropertyRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetGetProfilePropertyResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for GetProfileProperty no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) GetPrompt(r *api.GetPromptRequest) (*api.GetPromptResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_GetPromptRequest{
			GetPromptRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending GetPromptRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetGetPromptResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for GetPrompt no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) GetProperty(r *api.GetPropertyRequest) (*api.GetPropertyResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_GetPropertyRequest{
			GetPropertyRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending GetPropertyRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetGetPropertyResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for GetProperty no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) Inject(r *api.InjectRequest) (*api.InjectResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_InjectRequest{
			InjectRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending InjectRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetInjectResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for Inject no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) InvokeFunction(r *api.InvokeFunctionRequest) (*api.InvokeFunctionResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_InvokeFunctionRequest{
			InvokeFunctionRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending InvokeFunctionRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetInvokeFunctionResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for InvokeFunction no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) ListProfiles(r *api.ListProfilesRequest) (*api.ListProfilesResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_ListProfilesRequest{
			ListProfilesRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending ListProfilesRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetListProfilesResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for ListProfiles no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) ListSessions(r *api.ListSessionsRequest) (*api.ListSessionsResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_ListSessionsRequest{
			ListSessionsRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending ListSessionsRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetListSessionsResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for ListSessions no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) MenuItem(r *api.MenuItemRequest) (*api.MenuItemResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_MenuItemRequest{
			MenuItemRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending MenuItemRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetMenuItemResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for MenuItem no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) Notification(r *api.NotificationRequest) (*api.NotificationResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_NotificationRequest{
			NotificationRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending NotificationRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetNotificationResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for Notification no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) Preferences(r *api.PreferencesRequest) (*api.PreferencesResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_PreferencesRequest{
			PreferencesRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending PreferencesRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetPreferencesResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for Preferences no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) RegisterTool(r *api.RegisterToolRequest) (*api.RegisterToolResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_RegisterToolRequest{
			RegisterToolRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending RegisterToolRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetRegisterToolResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for RegisterTool no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) ReorderTabs(r *api.ReorderTabsRequest) (*api.ReorderTabsResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_ReorderTabsRequest{
			ReorderTabsRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending ReorderTabsRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetReorderTabsResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for ReorderTabs no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) RestartSession(r *api.RestartSessionRequest) (*api.RestartSessionResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_RestartSessionRequest{
			RestartSessionRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending RestartSessionRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetRestartSessionResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for RestartSession no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) SavedArrangement(r *api.SavedArrangementRequest) (*api.SavedArrangementResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_SavedArrangementRequest{
			SavedArrangementRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending SavedArrangementRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetSavedArrangementResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for SavedArrangement no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) Selection(r *api.SelectionRequest) (*api.SelectionResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_SelectionRequest{
			SelectionRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending SelectionRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetSelectionResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for Selection no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) SendText(r *api.SendTextRequest) (*api.SendTextResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_SendTextRequest{
			SendTextRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending SendTextRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetSendTextResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for SendText no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) ServerOriginatedRpcResult(r *api.ServerOriginatedRPCResultRequest) (*api.ServerOriginatedRPCResultResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_ServerOriginatedRpcResultRequest{
			ServerOriginatedRpcResultRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending ServerOriginatedRPCResultRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetServerOriginatedRpcResultResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for ServerOriginatedRpcResult no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) SetBroadcastDomains(r *api.SetBroadcastDomainsRequest) (*api.SetBroadcastDomainsResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_SetBroadcastDomainsRequest{
			SetBroadcastDomainsRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending SetBroadcastDomainsRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetSetBroadcastDomainsResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for SetBroadcastDomains no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) SetProfileProperty(r *api.SetProfilePropertyRequest) (*api.SetProfilePropertyResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_SetProfilePropertyRequest{
			SetProfilePropertyRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending SetProfilePropertyRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetSetProfilePropertyResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for SetProfileProperty no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) SetProperty(r *api.SetPropertyRequest) (*api.SetPropertyResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_SetPropertyRequest{
			SetPropertyRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending SetPropertyRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetSetPropertyResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for SetProperty no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) SetTabLayout(r *api.SetTabLayoutRequest) (*api.SetTabLayoutResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_SetTabLayoutRequest{
			SetTabLayoutRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending SetTabLayoutRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetSetTabLayoutResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for SetTabLayout no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) SplitPane(r *api.SplitPaneRequest) (*api.SplitPaneResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_SplitPaneRequest{
			SplitPaneRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending SplitPaneRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetSplitPaneResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for SplitPane no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) StatusBarComponent(r *api.StatusBarComponentRequest) (*api.StatusBarComponentResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_StatusBarComponentRequest{
			StatusBarComponentRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending StatusBarComponentRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetStatusBarComponentResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for StatusBarComponent no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) Tmux(r *api.TmuxRequest) (*api.TmuxResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_TmuxRequest{
			TmuxRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending TmuxRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetTmuxResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for Tmux no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) Transaction(r *api.TransactionRequest) (*api.TransactionResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_TransactionRequest{
			TransactionRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending TransactionRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetTransactionResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for Transaction no answer channel returned")
	return nil, errors.New("unexpected error")
}

func (I *ITerm2) Variable(r *api.VariableRequest) (*api.VariableResponse, error) {
	m := &api.ClientOriginatedMessage{
		Id: I.NewID(),
		Submessage: &api.ClientOriginatedMessage_VariableRequest{
			VariableRequest: r,
		},
	}
	c, err := I.SendMessage(m)
	if err != nil {
		I.logger.Errorf("error sending VariableRequest message ti iterm2:", err)
		return nil, err
	}
	if c != nil {
		a := <-c
		return a.GetVariableResponse(), nil
	}
	I.logger.Errorf("unexpected error calling rpc for Variable no answer channel returned")
	return nil, errors.New("unexpected error")
}