sanderling/internal/driver/ioscompanion/companionpb/idb_grpc.pb.go

//
// Copyright (c) Meta Platforms, Inc. and affiliates.
//
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.

// Pinned to the simulator companion v1.1.8 and matches the embedded binary.
// Do NOT regenerate this file from upstream HEAD: HEAD has drifted from the
// pinned binary, so regenerating would produce stubs that no longer match the
// companion this driver speaks to. The only local change versus the upstream
// source is the go_package option below, which targets the committed stub
// package internal/driver/ioscompanion/companionpb. Regenerate the stubs from
// the repository root with:
//   buf generate proto/idbcompanion --template proto/idbcompanion/buf.gen.yaml

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.0
// - protoc             (unknown)
// source: idb.proto

package companionpb

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

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

const (
	CompanionService_Connect_FullMethodName               = "/idb.CompanionService/connect"
	CompanionService_Debugserver_FullMethodName           = "/idb.CompanionService/debugserver"
	CompanionService_Dap_FullMethodName                   = "/idb.CompanionService/dap"
	CompanionService_Describe_FullMethodName              = "/idb.CompanionService/describe"
	CompanionService_Install_FullMethodName               = "/idb.CompanionService/install"
	CompanionService_InstrumentsRun_FullMethodName        = "/idb.CompanionService/instruments_run"
	CompanionService_Log_FullMethodName                   = "/idb.CompanionService/log"
	CompanionService_XctraceRecord_FullMethodName         = "/idb.CompanionService/xctrace_record"
	CompanionService_AccessibilityInfo_FullMethodName     = "/idb.CompanionService/accessibility_info"
	CompanionService_Focus_FullMethodName                 = "/idb.CompanionService/focus"
	CompanionService_Hid_FullMethodName                   = "/idb.CompanionService/hid"
	CompanionService_OpenUrl_FullMethodName               = "/idb.CompanionService/open_url"
	CompanionService_SetLocation_FullMethodName           = "/idb.CompanionService/set_location"
	CompanionService_SendNotification_FullMethodName      = "/idb.CompanionService/send_notification"
	CompanionService_SimulateMemoryWarning_FullMethodName = "/idb.CompanionService/simulate_memory_warning"
	CompanionService_Approve_FullMethodName               = "/idb.CompanionService/approve"
	CompanionService_Revoke_FullMethodName                = "/idb.CompanionService/revoke"
	CompanionService_ClearKeychain_FullMethodName         = "/idb.CompanionService/clear_keychain"
	CompanionService_ContactsUpdate_FullMethodName        = "/idb.CompanionService/contacts_update"
	CompanionService_Setting_FullMethodName               = "/idb.CompanionService/setting"
	CompanionService_GetSetting_FullMethodName            = "/idb.CompanionService/get_setting"
	CompanionService_ListSettings_FullMethodName          = "/idb.CompanionService/list_settings"
	CompanionService_Launch_FullMethodName                = "/idb.CompanionService/launch"
	CompanionService_ListApps_FullMethodName              = "/idb.CompanionService/list_apps"
	CompanionService_Terminate_FullMethodName             = "/idb.CompanionService/terminate"
	CompanionService_Uninstall_FullMethodName             = "/idb.CompanionService/uninstall"
	CompanionService_AddMedia_FullMethodName              = "/idb.CompanionService/add_media"
	CompanionService_Record_FullMethodName                = "/idb.CompanionService/record"
	CompanionService_Screenshot_FullMethodName            = "/idb.CompanionService/screenshot"
	CompanionService_VideoStream_FullMethodName           = "/idb.CompanionService/video_stream"
	CompanionService_CrashDelete_FullMethodName           = "/idb.CompanionService/crash_delete"
	CompanionService_CrashList_FullMethodName             = "/idb.CompanionService/crash_list"
	CompanionService_CrashShow_FullMethodName             = "/idb.CompanionService/crash_show"
	CompanionService_XctestListBundles_FullMethodName     = "/idb.CompanionService/xctest_list_bundles"
	CompanionService_XctestListTests_FullMethodName       = "/idb.CompanionService/xctest_list_tests"
	CompanionService_XctestRun_FullMethodName             = "/idb.CompanionService/xctest_run"
	CompanionService_Ls_FullMethodName                    = "/idb.CompanionService/ls"
	CompanionService_Mkdir_FullMethodName                 = "/idb.CompanionService/mkdir"
	CompanionService_Mv_FullMethodName                    = "/idb.CompanionService/mv"
	CompanionService_Rm_FullMethodName                    = "/idb.CompanionService/rm"
	CompanionService_Pull_FullMethodName                  = "/idb.CompanionService/pull"
	CompanionService_Push_FullMethodName                  = "/idb.CompanionService/push"
	CompanionService_Tail_FullMethodName                  = "/idb.CompanionService/tail"
)

// CompanionServiceClient is the client API for CompanionService 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.
//
// The idb companion service definition.
type CompanionServiceClient interface {
	// Management
	Connect(ctx context.Context, in *ConnectRequest, opts ...grpc.CallOption) (*ConnectResponse, error)
	Debugserver(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[DebugServerRequest, DebugServerResponse], error)
	Dap(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[DapRequest, DapResponse], error)
	Describe(ctx context.Context, in *TargetDescriptionRequest, opts ...grpc.CallOption) (*TargetDescriptionResponse, error)
	Install(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[InstallRequest, InstallResponse], error)
	InstrumentsRun(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[InstrumentsRunRequest, InstrumentsRunResponse], error)
	Log(ctx context.Context, in *LogRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[LogResponse], error)
	XctraceRecord(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[XctraceRecordRequest, XctraceRecordResponse], error)
	// Interaction
	AccessibilityInfo(ctx context.Context, in *AccessibilityInfoRequest, opts ...grpc.CallOption) (*AccessibilityInfoResponse, error)
	Focus(ctx context.Context, in *FocusRequest, opts ...grpc.CallOption) (*FocusResponse, error)
	Hid(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[HIDEvent, HIDResponse], error)
	OpenUrl(ctx context.Context, in *OpenUrlRequest, opts ...grpc.CallOption) (*OpenUrlRequest, error)
	SetLocation(ctx context.Context, in *SetLocationRequest, opts ...grpc.CallOption) (*SetLocationResponse, error)
	SendNotification(ctx context.Context, in *SendNotificationRequest, opts ...grpc.CallOption) (*SendNotificationResponse, error)
	SimulateMemoryWarning(ctx context.Context, in *SimulateMemoryWarningRequest, opts ...grpc.CallOption) (*SimulateMemoryWarningResponse, error)
	// Settings
	Approve(ctx context.Context, in *ApproveRequest, opts ...grpc.CallOption) (*ApproveResponse, error)
	Revoke(ctx context.Context, in *RevokeRequest, opts ...grpc.CallOption) (*RevokeResponse, error)
	ClearKeychain(ctx context.Context, in *ClearKeychainRequest, opts ...grpc.CallOption) (*ClearKeychainResponse, error)
	ContactsUpdate(ctx context.Context, in *ContactsUpdateRequest, opts ...grpc.CallOption) (*ContactsUpdateResponse, error)
	Setting(ctx context.Context, in *SettingRequest, opts ...grpc.CallOption) (*SettingResponse, error)
	GetSetting(ctx context.Context, in *GetSettingRequest, opts ...grpc.CallOption) (*GetSettingResponse, error)
	ListSettings(ctx context.Context, in *ListSettingRequest, opts ...grpc.CallOption) (*ListSettingResponse, error)
	// App
	Launch(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[LaunchRequest, LaunchResponse], error)
	ListApps(ctx context.Context, in *ListAppsRequest, opts ...grpc.CallOption) (*ListAppsResponse, error)
	Terminate(ctx context.Context, in *TerminateRequest, opts ...grpc.CallOption) (*TerminateResponse, error)
	Uninstall(ctx context.Context, in *UninstallRequest, opts ...grpc.CallOption) (*UninstallResponse, error)
	// Video/Audio
	AddMedia(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[AddMediaRequest, AddMediaResponse], error)
	Record(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[RecordRequest, RecordResponse], error)
	Screenshot(ctx context.Context, in *ScreenshotRequest, opts ...grpc.CallOption) (*ScreenshotResponse, error)
	VideoStream(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[VideoStreamRequest, VideoStreamResponse], error)
	// Crash Operations
	CrashDelete(ctx context.Context, in *CrashLogQuery, opts ...grpc.CallOption) (*CrashLogResponse, error)
	CrashList(ctx context.Context, in *CrashLogQuery, opts ...grpc.CallOption) (*CrashLogResponse, error)
	CrashShow(ctx context.Context, in *CrashShowRequest, opts ...grpc.CallOption) (*CrashShowResponse, error)
	// xctest operations
	XctestListBundles(ctx context.Context, in *XctestListBundlesRequest, opts ...grpc.CallOption) (*XctestListBundlesResponse, error)
	XctestListTests(ctx context.Context, in *XctestListTestsRequest, opts ...grpc.CallOption) (*XctestListTestsResponse, error)
	XctestRun(ctx context.Context, in *XctestRunRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[XctestRunResponse], error)
	// File Operations
	Ls(ctx context.Context, in *LsRequest, opts ...grpc.CallOption) (*LsResponse, error)
	Mkdir(ctx context.Context, in *MkdirRequest, opts ...grpc.CallOption) (*MkdirResponse, error)
	Mv(ctx context.Context, in *MvRequest, opts ...grpc.CallOption) (*MvResponse, error)
	Rm(ctx context.Context, in *RmRequest, opts ...grpc.CallOption) (*RmResponse, error)
	Pull(ctx context.Context, in *PullRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[PullResponse], error)
	Push(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[PushRequest, PushResponse], error)
	Tail(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[TailRequest, TailResponse], error)
}

type companionServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCompanionServiceClient(cc grpc.ClientConnInterface) CompanionServiceClient {
	return &companionServiceClient{cc}
}

func (c *companionServiceClient) Connect(ctx context.Context, in *ConnectRequest, opts ...grpc.CallOption) (*ConnectResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConnectResponse)
	err := c.cc.Invoke(ctx, CompanionService_Connect_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Debugserver(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[DebugServerRequest, DebugServerResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[0], CompanionService_Debugserver_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[DebugServerRequest, DebugServerResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_DebugserverClient = grpc.BidiStreamingClient[DebugServerRequest, DebugServerResponse]

func (c *companionServiceClient) Dap(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[DapRequest, DapResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[1], CompanionService_Dap_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[DapRequest, DapResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_DapClient = grpc.BidiStreamingClient[DapRequest, DapResponse]

func (c *companionServiceClient) Describe(ctx context.Context, in *TargetDescriptionRequest, opts ...grpc.CallOption) (*TargetDescriptionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TargetDescriptionResponse)
	err := c.cc.Invoke(ctx, CompanionService_Describe_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Install(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[InstallRequest, InstallResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[2], CompanionService_Install_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[InstallRequest, InstallResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_InstallClient = grpc.BidiStreamingClient[InstallRequest, InstallResponse]

func (c *companionServiceClient) InstrumentsRun(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[InstrumentsRunRequest, InstrumentsRunResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[3], CompanionService_InstrumentsRun_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[InstrumentsRunRequest, InstrumentsRunResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_InstrumentsRunClient = grpc.BidiStreamingClient[InstrumentsRunRequest, InstrumentsRunResponse]

func (c *companionServiceClient) Log(ctx context.Context, in *LogRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[LogResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[4], CompanionService_Log_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[LogRequest, LogResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_LogClient = grpc.ServerStreamingClient[LogResponse]

func (c *companionServiceClient) XctraceRecord(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[XctraceRecordRequest, XctraceRecordResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[5], CompanionService_XctraceRecord_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[XctraceRecordRequest, XctraceRecordResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_XctraceRecordClient = grpc.BidiStreamingClient[XctraceRecordRequest, XctraceRecordResponse]

func (c *companionServiceClient) AccessibilityInfo(ctx context.Context, in *AccessibilityInfoRequest, opts ...grpc.CallOption) (*AccessibilityInfoResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AccessibilityInfoResponse)
	err := c.cc.Invoke(ctx, CompanionService_AccessibilityInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Focus(ctx context.Context, in *FocusRequest, opts ...grpc.CallOption) (*FocusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(FocusResponse)
	err := c.cc.Invoke(ctx, CompanionService_Focus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Hid(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[HIDEvent, HIDResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[6], CompanionService_Hid_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[HIDEvent, HIDResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_HidClient = grpc.ClientStreamingClient[HIDEvent, HIDResponse]

func (c *companionServiceClient) OpenUrl(ctx context.Context, in *OpenUrlRequest, opts ...grpc.CallOption) (*OpenUrlRequest, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(OpenUrlRequest)
	err := c.cc.Invoke(ctx, CompanionService_OpenUrl_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) SetLocation(ctx context.Context, in *SetLocationRequest, opts ...grpc.CallOption) (*SetLocationResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SetLocationResponse)
	err := c.cc.Invoke(ctx, CompanionService_SetLocation_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) SendNotification(ctx context.Context, in *SendNotificationRequest, opts ...grpc.CallOption) (*SendNotificationResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SendNotificationResponse)
	err := c.cc.Invoke(ctx, CompanionService_SendNotification_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) SimulateMemoryWarning(ctx context.Context, in *SimulateMemoryWarningRequest, opts ...grpc.CallOption) (*SimulateMemoryWarningResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SimulateMemoryWarningResponse)
	err := c.cc.Invoke(ctx, CompanionService_SimulateMemoryWarning_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Approve(ctx context.Context, in *ApproveRequest, opts ...grpc.CallOption) (*ApproveResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ApproveResponse)
	err := c.cc.Invoke(ctx, CompanionService_Approve_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Revoke(ctx context.Context, in *RevokeRequest, opts ...grpc.CallOption) (*RevokeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RevokeResponse)
	err := c.cc.Invoke(ctx, CompanionService_Revoke_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) ClearKeychain(ctx context.Context, in *ClearKeychainRequest, opts ...grpc.CallOption) (*ClearKeychainResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ClearKeychainResponse)
	err := c.cc.Invoke(ctx, CompanionService_ClearKeychain_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) ContactsUpdate(ctx context.Context, in *ContactsUpdateRequest, opts ...grpc.CallOption) (*ContactsUpdateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ContactsUpdateResponse)
	err := c.cc.Invoke(ctx, CompanionService_ContactsUpdate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Setting(ctx context.Context, in *SettingRequest, opts ...grpc.CallOption) (*SettingResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SettingResponse)
	err := c.cc.Invoke(ctx, CompanionService_Setting_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) GetSetting(ctx context.Context, in *GetSettingRequest, opts ...grpc.CallOption) (*GetSettingResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetSettingResponse)
	err := c.cc.Invoke(ctx, CompanionService_GetSetting_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) ListSettings(ctx context.Context, in *ListSettingRequest, opts ...grpc.CallOption) (*ListSettingResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListSettingResponse)
	err := c.cc.Invoke(ctx, CompanionService_ListSettings_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Launch(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[LaunchRequest, LaunchResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[7], CompanionService_Launch_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[LaunchRequest, LaunchResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_LaunchClient = grpc.BidiStreamingClient[LaunchRequest, LaunchResponse]

func (c *companionServiceClient) ListApps(ctx context.Context, in *ListAppsRequest, opts ...grpc.CallOption) (*ListAppsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListAppsResponse)
	err := c.cc.Invoke(ctx, CompanionService_ListApps_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Terminate(ctx context.Context, in *TerminateRequest, opts ...grpc.CallOption) (*TerminateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TerminateResponse)
	err := c.cc.Invoke(ctx, CompanionService_Terminate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Uninstall(ctx context.Context, in *UninstallRequest, opts ...grpc.CallOption) (*UninstallResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UninstallResponse)
	err := c.cc.Invoke(ctx, CompanionService_Uninstall_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) AddMedia(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[AddMediaRequest, AddMediaResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[8], CompanionService_AddMedia_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[AddMediaRequest, AddMediaResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_AddMediaClient = grpc.ClientStreamingClient[AddMediaRequest, AddMediaResponse]

func (c *companionServiceClient) Record(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[RecordRequest, RecordResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[9], CompanionService_Record_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[RecordRequest, RecordResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_RecordClient = grpc.BidiStreamingClient[RecordRequest, RecordResponse]

func (c *companionServiceClient) Screenshot(ctx context.Context, in *ScreenshotRequest, opts ...grpc.CallOption) (*ScreenshotResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ScreenshotResponse)
	err := c.cc.Invoke(ctx, CompanionService_Screenshot_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) VideoStream(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[VideoStreamRequest, VideoStreamResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[10], CompanionService_VideoStream_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[VideoStreamRequest, VideoStreamResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_VideoStreamClient = grpc.BidiStreamingClient[VideoStreamRequest, VideoStreamResponse]

func (c *companionServiceClient) CrashDelete(ctx context.Context, in *CrashLogQuery, opts ...grpc.CallOption) (*CrashLogResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CrashLogResponse)
	err := c.cc.Invoke(ctx, CompanionService_CrashDelete_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) CrashList(ctx context.Context, in *CrashLogQuery, opts ...grpc.CallOption) (*CrashLogResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CrashLogResponse)
	err := c.cc.Invoke(ctx, CompanionService_CrashList_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) CrashShow(ctx context.Context, in *CrashShowRequest, opts ...grpc.CallOption) (*CrashShowResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CrashShowResponse)
	err := c.cc.Invoke(ctx, CompanionService_CrashShow_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) XctestListBundles(ctx context.Context, in *XctestListBundlesRequest, opts ...grpc.CallOption) (*XctestListBundlesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(XctestListBundlesResponse)
	err := c.cc.Invoke(ctx, CompanionService_XctestListBundles_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) XctestListTests(ctx context.Context, in *XctestListTestsRequest, opts ...grpc.CallOption) (*XctestListTestsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(XctestListTestsResponse)
	err := c.cc.Invoke(ctx, CompanionService_XctestListTests_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) XctestRun(ctx context.Context, in *XctestRunRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[XctestRunResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[11], CompanionService_XctestRun_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[XctestRunRequest, XctestRunResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_XctestRunClient = grpc.ServerStreamingClient[XctestRunResponse]

func (c *companionServiceClient) Ls(ctx context.Context, in *LsRequest, opts ...grpc.CallOption) (*LsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(LsResponse)
	err := c.cc.Invoke(ctx, CompanionService_Ls_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Mkdir(ctx context.Context, in *MkdirRequest, opts ...grpc.CallOption) (*MkdirResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MkdirResponse)
	err := c.cc.Invoke(ctx, CompanionService_Mkdir_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Mv(ctx context.Context, in *MvRequest, opts ...grpc.CallOption) (*MvResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MvResponse)
	err := c.cc.Invoke(ctx, CompanionService_Mv_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Rm(ctx context.Context, in *RmRequest, opts ...grpc.CallOption) (*RmResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RmResponse)
	err := c.cc.Invoke(ctx, CompanionService_Rm_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companionServiceClient) Pull(ctx context.Context, in *PullRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[PullResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[12], CompanionService_Pull_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[PullRequest, PullResponse]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_PullClient = grpc.ServerStreamingClient[PullResponse]

func (c *companionServiceClient) Push(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[PushRequest, PushResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[13], CompanionService_Push_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[PushRequest, PushResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_PushClient = grpc.ClientStreamingClient[PushRequest, PushResponse]

func (c *companionServiceClient) Tail(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[TailRequest, TailResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CompanionService_ServiceDesc.Streams[14], CompanionService_Tail_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[TailRequest, TailResponse]{ClientStream: stream}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_TailClient = grpc.BidiStreamingClient[TailRequest, TailResponse]

// CompanionServiceServer is the server API for CompanionService service.
// All implementations must embed UnimplementedCompanionServiceServer
// for forward compatibility.
//
// The idb companion service definition.
type CompanionServiceServer interface {
	// Management
	Connect(context.Context, *ConnectRequest) (*ConnectResponse, error)
	Debugserver(grpc.BidiStreamingServer[DebugServerRequest, DebugServerResponse]) error
	Dap(grpc.BidiStreamingServer[DapRequest, DapResponse]) error
	Describe(context.Context, *TargetDescriptionRequest) (*TargetDescriptionResponse, error)
	Install(grpc.BidiStreamingServer[InstallRequest, InstallResponse]) error
	InstrumentsRun(grpc.BidiStreamingServer[InstrumentsRunRequest, InstrumentsRunResponse]) error
	Log(*LogRequest, grpc.ServerStreamingServer[LogResponse]) error
	XctraceRecord(grpc.BidiStreamingServer[XctraceRecordRequest, XctraceRecordResponse]) error
	// Interaction
	AccessibilityInfo(context.Context, *AccessibilityInfoRequest) (*AccessibilityInfoResponse, error)
	Focus(context.Context, *FocusRequest) (*FocusResponse, error)
	Hid(grpc.ClientStreamingServer[HIDEvent, HIDResponse]) error
	OpenUrl(context.Context, *OpenUrlRequest) (*OpenUrlRequest, error)
	SetLocation(context.Context, *SetLocationRequest) (*SetLocationResponse, error)
	SendNotification(context.Context, *SendNotificationRequest) (*SendNotificationResponse, error)
	SimulateMemoryWarning(context.Context, *SimulateMemoryWarningRequest) (*SimulateMemoryWarningResponse, error)
	// Settings
	Approve(context.Context, *ApproveRequest) (*ApproveResponse, error)
	Revoke(context.Context, *RevokeRequest) (*RevokeResponse, error)
	ClearKeychain(context.Context, *ClearKeychainRequest) (*ClearKeychainResponse, error)
	ContactsUpdate(context.Context, *ContactsUpdateRequest) (*ContactsUpdateResponse, error)
	Setting(context.Context, *SettingRequest) (*SettingResponse, error)
	GetSetting(context.Context, *GetSettingRequest) (*GetSettingResponse, error)
	ListSettings(context.Context, *ListSettingRequest) (*ListSettingResponse, error)
	// App
	Launch(grpc.BidiStreamingServer[LaunchRequest, LaunchResponse]) error
	ListApps(context.Context, *ListAppsRequest) (*ListAppsResponse, error)
	Terminate(context.Context, *TerminateRequest) (*TerminateResponse, error)
	Uninstall(context.Context, *UninstallRequest) (*UninstallResponse, error)
	// Video/Audio
	AddMedia(grpc.ClientStreamingServer[AddMediaRequest, AddMediaResponse]) error
	Record(grpc.BidiStreamingServer[RecordRequest, RecordResponse]) error
	Screenshot(context.Context, *ScreenshotRequest) (*ScreenshotResponse, error)
	VideoStream(grpc.BidiStreamingServer[VideoStreamRequest, VideoStreamResponse]) error
	// Crash Operations
	CrashDelete(context.Context, *CrashLogQuery) (*CrashLogResponse, error)
	CrashList(context.Context, *CrashLogQuery) (*CrashLogResponse, error)
	CrashShow(context.Context, *CrashShowRequest) (*CrashShowResponse, error)
	// xctest operations
	XctestListBundles(context.Context, *XctestListBundlesRequest) (*XctestListBundlesResponse, error)
	XctestListTests(context.Context, *XctestListTestsRequest) (*XctestListTestsResponse, error)
	XctestRun(*XctestRunRequest, grpc.ServerStreamingServer[XctestRunResponse]) error
	// File Operations
	Ls(context.Context, *LsRequest) (*LsResponse, error)
	Mkdir(context.Context, *MkdirRequest) (*MkdirResponse, error)
	Mv(context.Context, *MvRequest) (*MvResponse, error)
	Rm(context.Context, *RmRequest) (*RmResponse, error)
	Pull(*PullRequest, grpc.ServerStreamingServer[PullResponse]) error
	Push(grpc.ClientStreamingServer[PushRequest, PushResponse]) error
	Tail(grpc.BidiStreamingServer[TailRequest, TailResponse]) error
	mustEmbedUnimplementedCompanionServiceServer()
}

// UnimplementedCompanionServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedCompanionServiceServer struct{}

func (UnimplementedCompanionServiceServer) Connect(context.Context, *ConnectRequest) (*ConnectResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Connect not implemented")
}
func (UnimplementedCompanionServiceServer) Debugserver(grpc.BidiStreamingServer[DebugServerRequest, DebugServerResponse]) error {
	return status.Error(codes.Unimplemented, "method Debugserver not implemented")
}
func (UnimplementedCompanionServiceServer) Dap(grpc.BidiStreamingServer[DapRequest, DapResponse]) error {
	return status.Error(codes.Unimplemented, "method Dap not implemented")
}
func (UnimplementedCompanionServiceServer) Describe(context.Context, *TargetDescriptionRequest) (*TargetDescriptionResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Describe not implemented")
}
func (UnimplementedCompanionServiceServer) Install(grpc.BidiStreamingServer[InstallRequest, InstallResponse]) error {
	return status.Error(codes.Unimplemented, "method Install not implemented")
}
func (UnimplementedCompanionServiceServer) InstrumentsRun(grpc.BidiStreamingServer[InstrumentsRunRequest, InstrumentsRunResponse]) error {
	return status.Error(codes.Unimplemented, "method InstrumentsRun not implemented")
}
func (UnimplementedCompanionServiceServer) Log(*LogRequest, grpc.ServerStreamingServer[LogResponse]) error {
	return status.Error(codes.Unimplemented, "method Log not implemented")
}
func (UnimplementedCompanionServiceServer) XctraceRecord(grpc.BidiStreamingServer[XctraceRecordRequest, XctraceRecordResponse]) error {
	return status.Error(codes.Unimplemented, "method XctraceRecord not implemented")
}
func (UnimplementedCompanionServiceServer) AccessibilityInfo(context.Context, *AccessibilityInfoRequest) (*AccessibilityInfoResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method AccessibilityInfo not implemented")
}
func (UnimplementedCompanionServiceServer) Focus(context.Context, *FocusRequest) (*FocusResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Focus not implemented")
}
func (UnimplementedCompanionServiceServer) Hid(grpc.ClientStreamingServer[HIDEvent, HIDResponse]) error {
	return status.Error(codes.Unimplemented, "method Hid not implemented")
}
func (UnimplementedCompanionServiceServer) OpenUrl(context.Context, *OpenUrlRequest) (*OpenUrlRequest, error) {
	return nil, status.Error(codes.Unimplemented, "method OpenUrl not implemented")
}
func (UnimplementedCompanionServiceServer) SetLocation(context.Context, *SetLocationRequest) (*SetLocationResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SetLocation not implemented")
}
func (UnimplementedCompanionServiceServer) SendNotification(context.Context, *SendNotificationRequest) (*SendNotificationResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SendNotification not implemented")
}
func (UnimplementedCompanionServiceServer) SimulateMemoryWarning(context.Context, *SimulateMemoryWarningRequest) (*SimulateMemoryWarningResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SimulateMemoryWarning not implemented")
}
func (UnimplementedCompanionServiceServer) Approve(context.Context, *ApproveRequest) (*ApproveResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Approve not implemented")
}
func (UnimplementedCompanionServiceServer) Revoke(context.Context, *RevokeRequest) (*RevokeResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Revoke not implemented")
}
func (UnimplementedCompanionServiceServer) ClearKeychain(context.Context, *ClearKeychainRequest) (*ClearKeychainResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ClearKeychain not implemented")
}
func (UnimplementedCompanionServiceServer) ContactsUpdate(context.Context, *ContactsUpdateRequest) (*ContactsUpdateResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ContactsUpdate not implemented")
}
func (UnimplementedCompanionServiceServer) Setting(context.Context, *SettingRequest) (*SettingResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Setting not implemented")
}
func (UnimplementedCompanionServiceServer) GetSetting(context.Context, *GetSettingRequest) (*GetSettingResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetSetting not implemented")
}
func (UnimplementedCompanionServiceServer) ListSettings(context.Context, *ListSettingRequest) (*ListSettingResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListSettings not implemented")
}
func (UnimplementedCompanionServiceServer) Launch(grpc.BidiStreamingServer[LaunchRequest, LaunchResponse]) error {
	return status.Error(codes.Unimplemented, "method Launch not implemented")
}
func (UnimplementedCompanionServiceServer) ListApps(context.Context, *ListAppsRequest) (*ListAppsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListApps not implemented")
}
func (UnimplementedCompanionServiceServer) Terminate(context.Context, *TerminateRequest) (*TerminateResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Terminate not implemented")
}
func (UnimplementedCompanionServiceServer) Uninstall(context.Context, *UninstallRequest) (*UninstallResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Uninstall not implemented")
}
func (UnimplementedCompanionServiceServer) AddMedia(grpc.ClientStreamingServer[AddMediaRequest, AddMediaResponse]) error {
	return status.Error(codes.Unimplemented, "method AddMedia not implemented")
}
func (UnimplementedCompanionServiceServer) Record(grpc.BidiStreamingServer[RecordRequest, RecordResponse]) error {
	return status.Error(codes.Unimplemented, "method Record not implemented")
}
func (UnimplementedCompanionServiceServer) Screenshot(context.Context, *ScreenshotRequest) (*ScreenshotResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Screenshot not implemented")
}
func (UnimplementedCompanionServiceServer) VideoStream(grpc.BidiStreamingServer[VideoStreamRequest, VideoStreamResponse]) error {
	return status.Error(codes.Unimplemented, "method VideoStream not implemented")
}
func (UnimplementedCompanionServiceServer) CrashDelete(context.Context, *CrashLogQuery) (*CrashLogResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CrashDelete not implemented")
}
func (UnimplementedCompanionServiceServer) CrashList(context.Context, *CrashLogQuery) (*CrashLogResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CrashList not implemented")
}
func (UnimplementedCompanionServiceServer) CrashShow(context.Context, *CrashShowRequest) (*CrashShowResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CrashShow not implemented")
}
func (UnimplementedCompanionServiceServer) XctestListBundles(context.Context, *XctestListBundlesRequest) (*XctestListBundlesResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method XctestListBundles not implemented")
}
func (UnimplementedCompanionServiceServer) XctestListTests(context.Context, *XctestListTestsRequest) (*XctestListTestsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method XctestListTests not implemented")
}
func (UnimplementedCompanionServiceServer) XctestRun(*XctestRunRequest, grpc.ServerStreamingServer[XctestRunResponse]) error {
	return status.Error(codes.Unimplemented, "method XctestRun not implemented")
}
func (UnimplementedCompanionServiceServer) Ls(context.Context, *LsRequest) (*LsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Ls not implemented")
}
func (UnimplementedCompanionServiceServer) Mkdir(context.Context, *MkdirRequest) (*MkdirResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Mkdir not implemented")
}
func (UnimplementedCompanionServiceServer) Mv(context.Context, *MvRequest) (*MvResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Mv not implemented")
}
func (UnimplementedCompanionServiceServer) Rm(context.Context, *RmRequest) (*RmResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Rm not implemented")
}
func (UnimplementedCompanionServiceServer) Pull(*PullRequest, grpc.ServerStreamingServer[PullResponse]) error {
	return status.Error(codes.Unimplemented, "method Pull not implemented")
}
func (UnimplementedCompanionServiceServer) Push(grpc.ClientStreamingServer[PushRequest, PushResponse]) error {
	return status.Error(codes.Unimplemented, "method Push not implemented")
}
func (UnimplementedCompanionServiceServer) Tail(grpc.BidiStreamingServer[TailRequest, TailResponse]) error {
	return status.Error(codes.Unimplemented, "method Tail not implemented")
}
func (UnimplementedCompanionServiceServer) mustEmbedUnimplementedCompanionServiceServer() {}
func (UnimplementedCompanionServiceServer) testEmbeddedByValue()                          {}

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

func RegisterCompanionServiceServer(s grpc.ServiceRegistrar, srv CompanionServiceServer) {
	// If the following call panics, it indicates UnimplementedCompanionServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&CompanionService_ServiceDesc, srv)
}

func _CompanionService_Connect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Connect(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Connect_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Connect(ctx, req.(*ConnectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Debugserver_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).Debugserver(&grpc.GenericServerStream[DebugServerRequest, DebugServerResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_DebugserverServer = grpc.BidiStreamingServer[DebugServerRequest, DebugServerResponse]

func _CompanionService_Dap_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).Dap(&grpc.GenericServerStream[DapRequest, DapResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_DapServer = grpc.BidiStreamingServer[DapRequest, DapResponse]

func _CompanionService_Describe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TargetDescriptionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Describe(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Describe_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Describe(ctx, req.(*TargetDescriptionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Install_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).Install(&grpc.GenericServerStream[InstallRequest, InstallResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_InstallServer = grpc.BidiStreamingServer[InstallRequest, InstallResponse]

func _CompanionService_InstrumentsRun_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).InstrumentsRun(&grpc.GenericServerStream[InstrumentsRunRequest, InstrumentsRunResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_InstrumentsRunServer = grpc.BidiStreamingServer[InstrumentsRunRequest, InstrumentsRunResponse]

func _CompanionService_Log_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LogRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CompanionServiceServer).Log(m, &grpc.GenericServerStream[LogRequest, LogResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_LogServer = grpc.ServerStreamingServer[LogResponse]

func _CompanionService_XctraceRecord_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).XctraceRecord(&grpc.GenericServerStream[XctraceRecordRequest, XctraceRecordResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_XctraceRecordServer = grpc.BidiStreamingServer[XctraceRecordRequest, XctraceRecordResponse]

func _CompanionService_AccessibilityInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccessibilityInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).AccessibilityInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_AccessibilityInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).AccessibilityInfo(ctx, req.(*AccessibilityInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Focus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FocusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Focus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Focus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Focus(ctx, req.(*FocusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Hid_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).Hid(&grpc.GenericServerStream[HIDEvent, HIDResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_HidServer = grpc.ClientStreamingServer[HIDEvent, HIDResponse]

func _CompanionService_OpenUrl_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OpenUrlRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).OpenUrl(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_OpenUrl_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).OpenUrl(ctx, req.(*OpenUrlRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_SetLocation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetLocationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).SetLocation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_SetLocation_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).SetLocation(ctx, req.(*SetLocationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_SendNotification_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SendNotificationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).SendNotification(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_SendNotification_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).SendNotification(ctx, req.(*SendNotificationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_SimulateMemoryWarning_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SimulateMemoryWarningRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).SimulateMemoryWarning(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_SimulateMemoryWarning_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).SimulateMemoryWarning(ctx, req.(*SimulateMemoryWarningRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Approve_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApproveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Approve(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Approve_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Approve(ctx, req.(*ApproveRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Revoke_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RevokeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Revoke(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Revoke_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Revoke(ctx, req.(*RevokeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_ClearKeychain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClearKeychainRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).ClearKeychain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_ClearKeychain_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).ClearKeychain(ctx, req.(*ClearKeychainRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_ContactsUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContactsUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).ContactsUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_ContactsUpdate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).ContactsUpdate(ctx, req.(*ContactsUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Setting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SettingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Setting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Setting_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Setting(ctx, req.(*SettingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_GetSetting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSettingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).GetSetting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_GetSetting_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).GetSetting(ctx, req.(*GetSettingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_ListSettings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSettingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).ListSettings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_ListSettings_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).ListSettings(ctx, req.(*ListSettingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Launch_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).Launch(&grpc.GenericServerStream[LaunchRequest, LaunchResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_LaunchServer = grpc.BidiStreamingServer[LaunchRequest, LaunchResponse]

func _CompanionService_ListApps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAppsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).ListApps(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_ListApps_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).ListApps(ctx, req.(*ListAppsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Terminate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TerminateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Terminate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Terminate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Terminate(ctx, req.(*TerminateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Uninstall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UninstallRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Uninstall(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Uninstall_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Uninstall(ctx, req.(*UninstallRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_AddMedia_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).AddMedia(&grpc.GenericServerStream[AddMediaRequest, AddMediaResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_AddMediaServer = grpc.ClientStreamingServer[AddMediaRequest, AddMediaResponse]

func _CompanionService_Record_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).Record(&grpc.GenericServerStream[RecordRequest, RecordResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_RecordServer = grpc.BidiStreamingServer[RecordRequest, RecordResponse]

func _CompanionService_Screenshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ScreenshotRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Screenshot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Screenshot_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Screenshot(ctx, req.(*ScreenshotRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_VideoStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).VideoStream(&grpc.GenericServerStream[VideoStreamRequest, VideoStreamResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_VideoStreamServer = grpc.BidiStreamingServer[VideoStreamRequest, VideoStreamResponse]

func _CompanionService_CrashDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CrashLogQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).CrashDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_CrashDelete_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).CrashDelete(ctx, req.(*CrashLogQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_CrashList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CrashLogQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).CrashList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_CrashList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).CrashList(ctx, req.(*CrashLogQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_CrashShow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CrashShowRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).CrashShow(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_CrashShow_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).CrashShow(ctx, req.(*CrashShowRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_XctestListBundles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(XctestListBundlesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).XctestListBundles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_XctestListBundles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).XctestListBundles(ctx, req.(*XctestListBundlesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_XctestListTests_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(XctestListTestsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).XctestListTests(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_XctestListTests_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).XctestListTests(ctx, req.(*XctestListTestsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_XctestRun_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(XctestRunRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CompanionServiceServer).XctestRun(m, &grpc.GenericServerStream[XctestRunRequest, XctestRunResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_XctestRunServer = grpc.ServerStreamingServer[XctestRunResponse]

func _CompanionService_Ls_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Ls(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Ls_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Ls(ctx, req.(*LsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Mkdir_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MkdirRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Mkdir(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Mkdir_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Mkdir(ctx, req.(*MkdirRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Mv_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MvRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Mv(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Mv_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Mv(ctx, req.(*MvRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Rm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RmRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanionServiceServer).Rm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CompanionService_Rm_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanionServiceServer).Rm(ctx, req.(*RmRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CompanionService_Pull_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PullRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CompanionServiceServer).Pull(m, &grpc.GenericServerStream[PullRequest, PullResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_PullServer = grpc.ServerStreamingServer[PullResponse]

func _CompanionService_Push_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).Push(&grpc.GenericServerStream[PushRequest, PushResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_PushServer = grpc.ClientStreamingServer[PushRequest, PushResponse]

func _CompanionService_Tail_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CompanionServiceServer).Tail(&grpc.GenericServerStream[TailRequest, TailResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CompanionService_TailServer = grpc.BidiStreamingServer[TailRequest, TailResponse]

// CompanionService_ServiceDesc is the grpc.ServiceDesc for CompanionService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var CompanionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "idb.CompanionService",
	HandlerType: (*CompanionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "connect",
			Handler:    _CompanionService_Connect_Handler,
		},
		{
			MethodName: "describe",
			Handler:    _CompanionService_Describe_Handler,
		},
		{
			MethodName: "accessibility_info",
			Handler:    _CompanionService_AccessibilityInfo_Handler,
		},
		{
			MethodName: "focus",
			Handler:    _CompanionService_Focus_Handler,
		},
		{
			MethodName: "open_url",
			Handler:    _CompanionService_OpenUrl_Handler,
		},
		{
			MethodName: "set_location",
			Handler:    _CompanionService_SetLocation_Handler,
		},
		{
			MethodName: "send_notification",
			Handler:    _CompanionService_SendNotification_Handler,
		},
		{
			MethodName: "simulate_memory_warning",
			Handler:    _CompanionService_SimulateMemoryWarning_Handler,
		},
		{
			MethodName: "approve",
			Handler:    _CompanionService_Approve_Handler,
		},
		{
			MethodName: "revoke",
			Handler:    _CompanionService_Revoke_Handler,
		},
		{
			MethodName: "clear_keychain",
			Handler:    _CompanionService_ClearKeychain_Handler,
		},
		{
			MethodName: "contacts_update",
			Handler:    _CompanionService_ContactsUpdate_Handler,
		},
		{
			MethodName: "setting",
			Handler:    _CompanionService_Setting_Handler,
		},
		{
			MethodName: "get_setting",
			Handler:    _CompanionService_GetSetting_Handler,
		},
		{
			MethodName: "list_settings",
			Handler:    _CompanionService_ListSettings_Handler,
		},
		{
			MethodName: "list_apps",
			Handler:    _CompanionService_ListApps_Handler,
		},
		{
			MethodName: "terminate",
			Handler:    _CompanionService_Terminate_Handler,
		},
		{
			MethodName: "uninstall",
			Handler:    _CompanionService_Uninstall_Handler,
		},
		{
			MethodName: "screenshot",
			Handler:    _CompanionService_Screenshot_Handler,
		},
		{
			MethodName: "crash_delete",
			Handler:    _CompanionService_CrashDelete_Handler,
		},
		{
			MethodName: "crash_list",
			Handler:    _CompanionService_CrashList_Handler,
		},
		{
			MethodName: "crash_show",
			Handler:    _CompanionService_CrashShow_Handler,
		},
		{
			MethodName: "xctest_list_bundles",
			Handler:    _CompanionService_XctestListBundles_Handler,
		},
		{
			MethodName: "xctest_list_tests",
			Handler:    _CompanionService_XctestListTests_Handler,
		},
		{
			MethodName: "ls",
			Handler:    _CompanionService_Ls_Handler,
		},
		{
			MethodName: "mkdir",
			Handler:    _CompanionService_Mkdir_Handler,
		},
		{
			MethodName: "mv",
			Handler:    _CompanionService_Mv_Handler,
		},
		{
			MethodName: "rm",
			Handler:    _CompanionService_Rm_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "debugserver",
			Handler:       _CompanionService_Debugserver_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "dap",
			Handler:       _CompanionService_Dap_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "install",
			Handler:       _CompanionService_Install_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "instruments_run",
			Handler:       _CompanionService_InstrumentsRun_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "log",
			Handler:       _CompanionService_Log_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "xctrace_record",
			Handler:       _CompanionService_XctraceRecord_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "hid",
			Handler:       _CompanionService_Hid_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "launch",
			Handler:       _CompanionService_Launch_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "add_media",
			Handler:       _CompanionService_AddMedia_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "record",
			Handler:       _CompanionService_Record_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "video_stream",
			Handler:       _CompanionService_VideoStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "xctest_run",
			Handler:       _CompanionService_XctestRun_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "pull",
			Handler:       _CompanionService_Pull_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "push",
			Handler:       _CompanionService_Push_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "tail",
			Handler:       _CompanionService_Tail_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "idb.proto",
}