skysign_proto

package
v0.0.0-...-acccf35 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 9, 2021 License: MIT Imports: 16 Imported by: 0

Documentation

Overview

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package skysign_proto is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Index

Constants

This section is empty.

Variables

View Source 
var (
	CommandType_name = map[int32]string{
		0:  "ARM",
		1:  "DISARM",
		2:  "UPLOAD",
		3:  "START",
		4:  "PAUSE",
		5:  "TAKEOFF",
		6:  "LAND",
		7:  "RETURN",
		99: "NONE",
	}
	CommandType_value = map[string]int32{
		"ARM":     0,
		"DISARM":  1,
		"UPLOAD":  2,
		"START":   3,
		"PAUSE":   4,
		"TAKEOFF": 5,
		"LAND":    6,
		"RETURN":  7,
		"NONE":    99,
	}
)

Enum value maps for CommandType.

View Source 
var ActionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.ActionService",
	HandlerType: (*ActionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetTrajectory",
			Handler:    _ActionService_GetTrajectory_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/action.proto",
}

ActionService_ServiceDesc is the grpc.ServiceDesc for ActionService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var AssignAssetsToFleetService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.AssignAssetsToFleetService",
	HandlerType: (*AssignAssetsToFleetServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetAssignments",
			Handler:    _AssignAssetsToFleetService_GetAssignments_Handler,
		},
		{
			MethodName: "UpdateAssignments",
			Handler:    _AssignAssetsToFleetService_UpdateAssignments_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/fleet_assignments.proto",
}

AssignAssetsToFleetService_ServiceDesc is the grpc.ServiceDesc for AssignAssetsToFleetService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ChangeFlightplanService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.ChangeFlightplanService",
	HandlerType: (*ChangeFlightplanServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ChangeNumberOfVehicles",
			Handler:    _ChangeFlightplanService_ChangeNumberOfVehicles_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/flightplan_change.proto",
}

ChangeFlightplanService_ServiceDesc is the grpc.ServiceDesc for ChangeFlightplanService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var CommunicationEdgeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.CommunicationEdgeService",
	HandlerType: (*CommunicationEdgeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PushTelemetry",
			Handler:    _CommunicationEdgeService_PushTelemetry_Handler,
		},
		{
			MethodName: "PullCommand",
			Handler:    _CommunicationEdgeService_PullCommand_Handler,
		},
		{
			MethodName: "PullUploadMission",
			Handler:    _CommunicationEdgeService_PullUploadMission_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/communication_edge.proto",
}

CommunicationEdgeService_ServiceDesc is the grpc.ServiceDesc for CommunicationEdgeService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var CommunicationUserService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.CommunicationUserService",
	HandlerType: (*CommunicationUserServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PushCommand",
			Handler:    _CommunicationUserService_PushCommand_Handler,
		},
		{
			MethodName: "PushUploadMission",
			Handler:    _CommunicationUserService_PushUploadMission_Handler,
		},
		{
			MethodName: "PullTelemetry",
			Handler:    _CommunicationUserService_PullTelemetry_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/communication_user.proto",
}

CommunicationUserService_ServiceDesc is the grpc.ServiceDesc for CommunicationUserService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ExecuteFlightplanService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.ExecuteFlightplanService",
	HandlerType: (*ExecuteFlightplanServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ExecuteFlightplan",
			Handler:    _ExecuteFlightplanService_ExecuteFlightplan_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/flightplan_execute.proto",
}

ExecuteFlightplanService_ServiceDesc is the grpc.ServiceDesc for ExecuteFlightplanService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var File_proto_action_proto protoreflect.FileDescriptor
View Source 
var File_proto_common_proto protoreflect.FileDescriptor
View Source 
var File_proto_communication_edge_proto protoreflect.FileDescriptor
View Source 
var File_proto_communication_user_proto protoreflect.FileDescriptor
View Source 
var File_proto_event_proto protoreflect.FileDescriptor
View Source 
var File_proto_fleet_assignments_proto protoreflect.FileDescriptor
View Source 
var File_proto_flightoperation_proto protoreflect.FileDescriptor
View Source 
var File_proto_flightplan_change_proto protoreflect.FileDescriptor
View Source 
var File_proto_flightplan_execute_proto protoreflect.FileDescriptor
View Source 
var File_proto_flightplan_proto protoreflect.FileDescriptor
View Source 
var File_proto_flightreport_proto protoreflect.FileDescriptor
View Source 
var File_proto_helper_user_proto protoreflect.FileDescriptor
View Source 
var File_proto_mission_proto protoreflect.FileDescriptor
View Source 
var File_proto_upload_mission_edge_proto protoreflect.FileDescriptor
View Source 
var File_proto_vehicle_proto protoreflect.FileDescriptor
View Source 
var HelperUserService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.HelperUserService",
	HandlerType: (*HelperUserServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetEllipsoidHeight",
			Handler:    _HelperUserService_GetEllipsoidHeight_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/helper_user.proto",
}

HelperUserService_ServiceDesc is the grpc.ServiceDesc for HelperUserService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ManageFlightplanService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.ManageFlightplanService",
	HandlerType: (*ManageFlightplanServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListFlightplans",
			Handler:    _ManageFlightplanService_ListFlightplans_Handler,
		},
		{
			MethodName: "GetFlightplan",
			Handler:    _ManageFlightplanService_GetFlightplan_Handler,
		},
		{
			MethodName: "CreateFlightplan",
			Handler:    _ManageFlightplanService_CreateFlightplan_Handler,
		},
		{
			MethodName: "UpdateFlightplan",
			Handler:    _ManageFlightplanService_UpdateFlightplan_Handler,
		},
		{
			MethodName: "DeleteFlightplan",
			Handler:    _ManageFlightplanService_DeleteFlightplan_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/flightplan.proto",
}

ManageFlightplanService_ServiceDesc is the grpc.ServiceDesc for ManageFlightplanService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ManageMissionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.ManageMissionService",
	HandlerType: (*ManageMissionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListMissions",
			Handler:    _ManageMissionService_ListMissions_Handler,
		},
		{
			MethodName: "GetMission",
			Handler:    _ManageMissionService_GetMission_Handler,
		},
		{
			MethodName: "CreateMission",
			Handler:    _ManageMissionService_CreateMission_Handler,
		},
		{
			MethodName: "UpdateMission",
			Handler:    _ManageMissionService_UpdateMission_Handler,
		},
		{
			MethodName: "DeleteMission",
			Handler:    _ManageMissionService_DeleteMission_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/mission.proto",
}

ManageMissionService_ServiceDesc is the grpc.ServiceDesc for ManageMissionService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ManageVehicleService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.ManageVehicleService",
	HandlerType: (*ManageVehicleServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListVehicles",
			Handler:    _ManageVehicleService_ListVehicles_Handler,
		},
		{
			MethodName: "GetVehicle",
			Handler:    _ManageVehicleService_GetVehicle_Handler,
		},
		{
			MethodName: "CreateVehicle",
			Handler:    _ManageVehicleService_CreateVehicle_Handler,
		},
		{
			MethodName: "UpdateVehicle",
			Handler:    _ManageVehicleService_UpdateVehicle_Handler,
		},
		{
			MethodName: "DeleteVehicle",
			Handler:    _ManageVehicleService_DeleteVehicle_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/vehicle.proto",
}

ManageVehicleService_ServiceDesc is the grpc.ServiceDesc for ManageVehicleService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var OperateFlightService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.OperateFlightService",
	HandlerType: (*OperateFlightServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListFlightoperations",
			Handler:    _OperateFlightService_ListFlightoperations_Handler,
		},
		{
			MethodName: "GetFlightoperation",
			Handler:    _OperateFlightService_GetFlightoperation_Handler,
		},
		{
			MethodName: "CompleteFlightoperation",
			Handler:    _OperateFlightService_CompleteFlightoperation_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/flightoperation.proto",
}

OperateFlightService_ServiceDesc is the grpc.ServiceDesc for OperateFlightService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ReportFlightService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.ReportFlightService",
	HandlerType: (*ReportFlightServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListFlightreports",
			Handler:    _ReportFlightService_ListFlightreports_Handler,
		},
		{
			MethodName: "GetFlightreport",
			Handler:    _ReportFlightService_GetFlightreport_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/flightreport.proto",
}

ReportFlightService_ServiceDesc is the grpc.ServiceDesc for ReportFlightService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var UploadMissionEdgeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "skysign_proto.UploadMissionEdgeService",
	HandlerType: (*UploadMissionEdgeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetUploadMission",
			Handler:    _UploadMissionEdgeService_GetUploadMission_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/upload_mission_edge.proto",
}

UploadMissionEdgeService_ServiceDesc is the grpc.ServiceDesc for UploadMissionEdgeService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

Functions

func RegisterActionServiceHandler 

func RegisterActionServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterActionServiceHandler registers the http handlers for service ActionService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterActionServiceHandlerClient 

func RegisterActionServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ActionServiceClient) error

RegisterActionServiceHandlerClient registers the http handlers for service ActionService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ActionServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ActionServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ActionServiceClient" to call the correct interceptors.

func RegisterActionServiceHandlerFromEndpoint 

func RegisterActionServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterActionServiceHandlerFromEndpoint is same as RegisterActionServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterActionServiceHandlerServer 

func RegisterActionServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ActionServiceServer) error

RegisterActionServiceHandlerServer registers the http handlers for service ActionService to "mux". UnaryRPC :call ActionServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterActionServiceHandlerFromEndpoint instead.

func RegisterActionServiceServer 

func RegisterActionServiceServer(s grpc.ServiceRegistrar, srv ActionServiceServer)

func RegisterAssignAssetsToFleetServiceHandler 

func RegisterAssignAssetsToFleetServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterAssignAssetsToFleetServiceHandler registers the http handlers for service AssignAssetsToFleetService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterAssignAssetsToFleetServiceHandlerClient 

func RegisterAssignAssetsToFleetServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AssignAssetsToFleetServiceClient) error

RegisterAssignAssetsToFleetServiceHandlerClient registers the http handlers for service AssignAssetsToFleetService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "AssignAssetsToFleetServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AssignAssetsToFleetServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "AssignAssetsToFleetServiceClient" to call the correct interceptors.

func RegisterAssignAssetsToFleetServiceHandlerFromEndpoint 

func RegisterAssignAssetsToFleetServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterAssignAssetsToFleetServiceHandlerFromEndpoint is same as RegisterAssignAssetsToFleetServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterAssignAssetsToFleetServiceHandlerServer 

func RegisterAssignAssetsToFleetServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server AssignAssetsToFleetServiceServer) error

RegisterAssignAssetsToFleetServiceHandlerServer registers the http handlers for service AssignAssetsToFleetService to "mux". UnaryRPC :call AssignAssetsToFleetServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterAssignAssetsToFleetServiceHandlerFromEndpoint instead.

func RegisterAssignAssetsToFleetServiceServer 

func RegisterAssignAssetsToFleetServiceServer(s grpc.ServiceRegistrar, srv AssignAssetsToFleetServiceServer)

func RegisterChangeFlightplanServiceHandler 

func RegisterChangeFlightplanServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterChangeFlightplanServiceHandler registers the http handlers for service ChangeFlightplanService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterChangeFlightplanServiceHandlerClient 

func RegisterChangeFlightplanServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ChangeFlightplanServiceClient) error

RegisterChangeFlightplanServiceHandlerClient registers the http handlers for service ChangeFlightplanService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ChangeFlightplanServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ChangeFlightplanServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ChangeFlightplanServiceClient" to call the correct interceptors.

func RegisterChangeFlightplanServiceHandlerFromEndpoint 

func RegisterChangeFlightplanServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterChangeFlightplanServiceHandlerFromEndpoint is same as RegisterChangeFlightplanServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterChangeFlightplanServiceHandlerServer 

func RegisterChangeFlightplanServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ChangeFlightplanServiceServer) error

RegisterChangeFlightplanServiceHandlerServer registers the http handlers for service ChangeFlightplanService to "mux". UnaryRPC :call ChangeFlightplanServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterChangeFlightplanServiceHandlerFromEndpoint instead.

func RegisterChangeFlightplanServiceServer 

func RegisterChangeFlightplanServiceServer(s grpc.ServiceRegistrar, srv ChangeFlightplanServiceServer)

func RegisterCommunicationEdgeServiceHandler 

func RegisterCommunicationEdgeServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCommunicationEdgeServiceHandler registers the http handlers for service CommunicationEdgeService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCommunicationEdgeServiceHandlerClient 

func RegisterCommunicationEdgeServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client CommunicationEdgeServiceClient) error

RegisterCommunicationEdgeServiceHandlerClient registers the http handlers for service CommunicationEdgeService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "CommunicationEdgeServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "CommunicationEdgeServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "CommunicationEdgeServiceClient" to call the correct interceptors.

func RegisterCommunicationEdgeServiceHandlerFromEndpoint 

func RegisterCommunicationEdgeServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCommunicationEdgeServiceHandlerFromEndpoint is same as RegisterCommunicationEdgeServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCommunicationEdgeServiceHandlerServer 

func RegisterCommunicationEdgeServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server CommunicationEdgeServiceServer) error

RegisterCommunicationEdgeServiceHandlerServer registers the http handlers for service CommunicationEdgeService to "mux". UnaryRPC :call CommunicationEdgeServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCommunicationEdgeServiceHandlerFromEndpoint instead.

func RegisterCommunicationEdgeServiceServer 

func RegisterCommunicationEdgeServiceServer(s grpc.ServiceRegistrar, srv CommunicationEdgeServiceServer)

func RegisterCommunicationUserServiceHandler 

func RegisterCommunicationUserServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCommunicationUserServiceHandler registers the http handlers for service CommunicationUserService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCommunicationUserServiceHandlerClient 

func RegisterCommunicationUserServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client CommunicationUserServiceClient) error

RegisterCommunicationUserServiceHandlerClient registers the http handlers for service CommunicationUserService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "CommunicationUserServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "CommunicationUserServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "CommunicationUserServiceClient" to call the correct interceptors.

func RegisterCommunicationUserServiceHandlerFromEndpoint 

func RegisterCommunicationUserServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCommunicationUserServiceHandlerFromEndpoint is same as RegisterCommunicationUserServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCommunicationUserServiceHandlerServer 

func RegisterCommunicationUserServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server CommunicationUserServiceServer) error

RegisterCommunicationUserServiceHandlerServer registers the http handlers for service CommunicationUserService to "mux". UnaryRPC :call CommunicationUserServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCommunicationUserServiceHandlerFromEndpoint instead.

func RegisterCommunicationUserServiceServer 

func RegisterCommunicationUserServiceServer(s grpc.ServiceRegistrar, srv CommunicationUserServiceServer)

func RegisterExecuteFlightplanServiceHandler 

func RegisterExecuteFlightplanServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterExecuteFlightplanServiceHandler registers the http handlers for service ExecuteFlightplanService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterExecuteFlightplanServiceHandlerClient 

func RegisterExecuteFlightplanServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ExecuteFlightplanServiceClient) error

RegisterExecuteFlightplanServiceHandlerClient registers the http handlers for service ExecuteFlightplanService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ExecuteFlightplanServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ExecuteFlightplanServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ExecuteFlightplanServiceClient" to call the correct interceptors.

func RegisterExecuteFlightplanServiceHandlerFromEndpoint 

func RegisterExecuteFlightplanServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterExecuteFlightplanServiceHandlerFromEndpoint is same as RegisterExecuteFlightplanServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterExecuteFlightplanServiceHandlerServer 

func RegisterExecuteFlightplanServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ExecuteFlightplanServiceServer) error

RegisterExecuteFlightplanServiceHandlerServer registers the http handlers for service ExecuteFlightplanService to "mux". UnaryRPC :call ExecuteFlightplanServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterExecuteFlightplanServiceHandlerFromEndpoint instead.

func RegisterExecuteFlightplanServiceServer 

func RegisterExecuteFlightplanServiceServer(s grpc.ServiceRegistrar, srv ExecuteFlightplanServiceServer)

func RegisterHelperUserServiceHandler 

func RegisterHelperUserServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterHelperUserServiceHandler registers the http handlers for service HelperUserService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterHelperUserServiceHandlerClient 

func RegisterHelperUserServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client HelperUserServiceClient) error

RegisterHelperUserServiceHandlerClient registers the http handlers for service HelperUserService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "HelperUserServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "HelperUserServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "HelperUserServiceClient" to call the correct interceptors.

func RegisterHelperUserServiceHandlerFromEndpoint 

func RegisterHelperUserServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterHelperUserServiceHandlerFromEndpoint is same as RegisterHelperUserServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterHelperUserServiceHandlerServer 

func RegisterHelperUserServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server HelperUserServiceServer) error

RegisterHelperUserServiceHandlerServer registers the http handlers for service HelperUserService to "mux". UnaryRPC :call HelperUserServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterHelperUserServiceHandlerFromEndpoint instead.

func RegisterHelperUserServiceServer 

func RegisterHelperUserServiceServer(s grpc.ServiceRegistrar, srv HelperUserServiceServer)

func RegisterManageFlightplanServiceHandler 

func RegisterManageFlightplanServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterManageFlightplanServiceHandler registers the http handlers for service ManageFlightplanService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterManageFlightplanServiceHandlerClient 

func RegisterManageFlightplanServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ManageFlightplanServiceClient) error

RegisterManageFlightplanServiceHandlerClient registers the http handlers for service ManageFlightplanService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ManageFlightplanServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ManageFlightplanServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ManageFlightplanServiceClient" to call the correct interceptors.

func RegisterManageFlightplanServiceHandlerFromEndpoint 

func RegisterManageFlightplanServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterManageFlightplanServiceHandlerFromEndpoint is same as RegisterManageFlightplanServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterManageFlightplanServiceHandlerServer 

func RegisterManageFlightplanServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ManageFlightplanServiceServer) error

RegisterManageFlightplanServiceHandlerServer registers the http handlers for service ManageFlightplanService to "mux". UnaryRPC :call ManageFlightplanServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterManageFlightplanServiceHandlerFromEndpoint instead.

func RegisterManageFlightplanServiceServer 

func RegisterManageFlightplanServiceServer(s grpc.ServiceRegistrar, srv ManageFlightplanServiceServer)

func RegisterManageMissionServiceHandler 

func RegisterManageMissionServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterManageMissionServiceHandler registers the http handlers for service ManageMissionService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterManageMissionServiceHandlerClient 

func RegisterManageMissionServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ManageMissionServiceClient) error

RegisterManageMissionServiceHandlerClient registers the http handlers for service ManageMissionService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ManageMissionServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ManageMissionServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ManageMissionServiceClient" to call the correct interceptors.

func RegisterManageMissionServiceHandlerFromEndpoint 

func RegisterManageMissionServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterManageMissionServiceHandlerFromEndpoint is same as RegisterManageMissionServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterManageMissionServiceHandlerServer 

func RegisterManageMissionServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ManageMissionServiceServer) error

RegisterManageMissionServiceHandlerServer registers the http handlers for service ManageMissionService to "mux". UnaryRPC :call ManageMissionServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterManageMissionServiceHandlerFromEndpoint instead.

func RegisterManageMissionServiceServer 

func RegisterManageMissionServiceServer(s grpc.ServiceRegistrar, srv ManageMissionServiceServer)

func RegisterManageVehicleServiceHandler 

func RegisterManageVehicleServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterManageVehicleServiceHandler registers the http handlers for service ManageVehicleService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterManageVehicleServiceHandlerClient 

func RegisterManageVehicleServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ManageVehicleServiceClient) error

RegisterManageVehicleServiceHandlerClient registers the http handlers for service ManageVehicleService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ManageVehicleServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ManageVehicleServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ManageVehicleServiceClient" to call the correct interceptors.

func RegisterManageVehicleServiceHandlerFromEndpoint 

func RegisterManageVehicleServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterManageVehicleServiceHandlerFromEndpoint is same as RegisterManageVehicleServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterManageVehicleServiceHandlerServer 

func RegisterManageVehicleServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ManageVehicleServiceServer) error

RegisterManageVehicleServiceHandlerServer registers the http handlers for service ManageVehicleService to "mux". UnaryRPC :call ManageVehicleServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterManageVehicleServiceHandlerFromEndpoint instead.

func RegisterManageVehicleServiceServer 

func RegisterManageVehicleServiceServer(s grpc.ServiceRegistrar, srv ManageVehicleServiceServer)

func RegisterOperateFlightServiceHandler 

func RegisterOperateFlightServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterOperateFlightServiceHandler registers the http handlers for service OperateFlightService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterOperateFlightServiceHandlerClient 

func RegisterOperateFlightServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client OperateFlightServiceClient) error

RegisterOperateFlightServiceHandlerClient registers the http handlers for service OperateFlightService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "OperateFlightServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "OperateFlightServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "OperateFlightServiceClient" to call the correct interceptors.

func RegisterOperateFlightServiceHandlerFromEndpoint 

func RegisterOperateFlightServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterOperateFlightServiceHandlerFromEndpoint is same as RegisterOperateFlightServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterOperateFlightServiceHandlerServer 

func RegisterOperateFlightServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server OperateFlightServiceServer) error

RegisterOperateFlightServiceHandlerServer registers the http handlers for service OperateFlightService to "mux". UnaryRPC :call OperateFlightServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterOperateFlightServiceHandlerFromEndpoint instead.

func RegisterOperateFlightServiceServer 

func RegisterOperateFlightServiceServer(s grpc.ServiceRegistrar, srv OperateFlightServiceServer)

func RegisterReportFlightServiceHandler 

func RegisterReportFlightServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterReportFlightServiceHandler registers the http handlers for service ReportFlightService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterReportFlightServiceHandlerClient 

func RegisterReportFlightServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ReportFlightServiceClient) error

RegisterReportFlightServiceHandlerClient registers the http handlers for service ReportFlightService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ReportFlightServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ReportFlightServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ReportFlightServiceClient" to call the correct interceptors.

func RegisterReportFlightServiceHandlerFromEndpoint 

func RegisterReportFlightServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterReportFlightServiceHandlerFromEndpoint is same as RegisterReportFlightServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterReportFlightServiceHandlerServer 

func RegisterReportFlightServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ReportFlightServiceServer) error

RegisterReportFlightServiceHandlerServer registers the http handlers for service ReportFlightService to "mux". UnaryRPC :call ReportFlightServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterReportFlightServiceHandlerFromEndpoint instead.

func RegisterReportFlightServiceServer 

func RegisterReportFlightServiceServer(s grpc.ServiceRegistrar, srv ReportFlightServiceServer)

func RegisterUploadMissionEdgeServiceHandler 

func RegisterUploadMissionEdgeServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterUploadMissionEdgeServiceHandler registers the http handlers for service UploadMissionEdgeService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterUploadMissionEdgeServiceHandlerClient 

func RegisterUploadMissionEdgeServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client UploadMissionEdgeServiceClient) error

RegisterUploadMissionEdgeServiceHandlerClient registers the http handlers for service UploadMissionEdgeService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "UploadMissionEdgeServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "UploadMissionEdgeServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "UploadMissionEdgeServiceClient" to call the correct interceptors.

func RegisterUploadMissionEdgeServiceHandlerFromEndpoint 

func RegisterUploadMissionEdgeServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterUploadMissionEdgeServiceHandlerFromEndpoint is same as RegisterUploadMissionEdgeServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterUploadMissionEdgeServiceHandlerServer 

func RegisterUploadMissionEdgeServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server UploadMissionEdgeServiceServer) error

RegisterUploadMissionEdgeServiceHandlerServer registers the http handlers for service UploadMissionEdgeService to "mux". UnaryRPC :call UploadMissionEdgeServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterUploadMissionEdgeServiceHandlerFromEndpoint instead.

func RegisterUploadMissionEdgeServiceServer 

func RegisterUploadMissionEdgeServiceServer(s grpc.ServiceRegistrar, srv UploadMissionEdgeServiceServer)

Types

type ActionServiceClient 

type ActionServiceClient interface {
	GetTrajectory(ctx context.Context, in *GetTrajectoryRequest, opts ...grpc.CallOption) (*GetTrajectoryResponse, error)
}

ActionServiceClient is the client API for ActionService 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.

func NewActionServiceClient 

func NewActionServiceClient(cc grpc.ClientConnInterface) ActionServiceClient

type ActionServiceServer 

type ActionServiceServer interface {
	GetTrajectory(context.Context, *GetTrajectoryRequest) (*GetTrajectoryResponse, error)
	// contains filtered or unexported methods
}

ActionServiceServer is the server API for ActionService service. All implementations must embed UnimplementedActionServiceServer for forward compatibility

type AssignAssetsToFleetServiceClient 

type AssignAssetsToFleetServiceClient interface {
	GetAssignments(ctx context.Context, in *GetAssignmentsRequest, opts ...grpc.CallOption) (*GetAssignmentsResponse, error)
	UpdateAssignments(ctx context.Context, in *UpdateAssignmentsRequest, opts ...grpc.CallOption) (*UpdateAssignmentsResponse, error)
}

AssignAssetsToFleetServiceClient is the client API for AssignAssetsToFleetService 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.

func NewAssignAssetsToFleetServiceClient 

func NewAssignAssetsToFleetServiceClient(cc grpc.ClientConnInterface) AssignAssetsToFleetServiceClient

type AssignAssetsToFleetServiceServer 

type AssignAssetsToFleetServiceServer interface {
	GetAssignments(context.Context, *GetAssignmentsRequest) (*GetAssignmentsResponse, error)
	UpdateAssignments(context.Context, *UpdateAssignmentsRequest) (*UpdateAssignmentsResponse, error)
	// contains filtered or unexported methods
}

AssignAssetsToFleetServiceServer is the server API for AssignAssetsToFleetService service. All implementations must embed UnimplementedAssignAssetsToFleetServiceServer for forward compatibility

type Assignment 

type Assignment struct {
	Id           string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	AssignmentId string `protobuf:"bytes,2,opt,name=assignment_id,json=assignmentId,proto3" json:"assignment_id,omitempty"`
	VehicleId    string `protobuf:"bytes,3,opt,name=vehicle_id,json=vehicleId,proto3" json:"vehicle_id,omitempty"`
	MissionId    string `protobuf:"bytes,4,opt,name=mission_id,json=missionId,proto3" json:"mission_id,omitempty"`
	// contains filtered or unexported fields
}

func (*Assignment) Descriptor deprecated 

func (*Assignment) Descriptor() ([]byte, []int)

Deprecated: Use Assignment.ProtoReflect.Descriptor instead.

func (*Assignment) GetAssignmentId 

func (x *Assignment) GetAssignmentId() string

func (*Assignment) GetId 

func (x *Assignment) GetId() string

func (*Assignment) GetMissionId 

func (x *Assignment) GetMissionId() string

func (*Assignment) GetVehicleId 

func (x *Assignment) GetVehicleId() string

func (*Assignment) ProtoMessage 

func (*Assignment) ProtoMessage()

func (*Assignment) ProtoReflect 

func (x *Assignment) ProtoReflect() protoreflect.Message

func (*Assignment) Reset 

func (x *Assignment) Reset()

func (*Assignment) String 

func (x *Assignment) String() string

type ChangeFlightplanServiceClient 

type ChangeFlightplanServiceClient interface {
	ChangeNumberOfVehicles(ctx context.Context, in *ChangeNumberOfVehiclesRequest, opts ...grpc.CallOption) (*ChangeNumberOfVehiclesResponse, error)
}

ChangeFlightplanServiceClient is the client API for ChangeFlightplanService 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.

func NewChangeFlightplanServiceClient 

func NewChangeFlightplanServiceClient(cc grpc.ClientConnInterface) ChangeFlightplanServiceClient

type ChangeFlightplanServiceServer 

type ChangeFlightplanServiceServer interface {
	ChangeNumberOfVehicles(context.Context, *ChangeNumberOfVehiclesRequest) (*ChangeNumberOfVehiclesResponse, error)
	// contains filtered or unexported methods
}

ChangeFlightplanServiceServer is the server API for ChangeFlightplanService service. All implementations must embed UnimplementedChangeFlightplanServiceServer for forward compatibility

type ChangeNumberOfVehiclesRequest 

type ChangeNumberOfVehiclesRequest struct {
	Id               string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	NumberOfVehicles int32  `protobuf:"varint,2,opt,name=number_of_vehicles,json=numberOfVehicles,proto3" json:"number_of_vehicles,omitempty"`
	// contains filtered or unexported fields
}

func (*ChangeNumberOfVehiclesRequest) Descriptor deprecated 

func (*ChangeNumberOfVehiclesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ChangeNumberOfVehiclesRequest.ProtoReflect.Descriptor instead.

func (*ChangeNumberOfVehiclesRequest) GetId 

func (x *ChangeNumberOfVehiclesRequest) GetId() string

func (*ChangeNumberOfVehiclesRequest) GetNumberOfVehicles 

func (x *ChangeNumberOfVehiclesRequest) GetNumberOfVehicles() int32

func (*ChangeNumberOfVehiclesRequest) ProtoMessage 

func (*ChangeNumberOfVehiclesRequest) ProtoMessage()

func (*ChangeNumberOfVehiclesRequest) ProtoReflect 

func (x *ChangeNumberOfVehiclesRequest) ProtoReflect() protoreflect.Message

func (*ChangeNumberOfVehiclesRequest) Reset 

func (x *ChangeNumberOfVehiclesRequest) Reset()

func (*ChangeNumberOfVehiclesRequest) String 

func (x *ChangeNumberOfVehiclesRequest) String() string

type ChangeNumberOfVehiclesResponse 

type ChangeNumberOfVehiclesResponse struct {
	Id               string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	NumberOfVehicles int32  `protobuf:"varint,2,opt,name=number_of_vehicles,json=numberOfVehicles,proto3" json:"number_of_vehicles,omitempty"`
	// contains filtered or unexported fields
}

func (*ChangeNumberOfVehiclesResponse) Descriptor deprecated 

func (*ChangeNumberOfVehiclesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ChangeNumberOfVehiclesResponse.ProtoReflect.Descriptor instead.

func (*ChangeNumberOfVehiclesResponse) GetId 

func (x *ChangeNumberOfVehiclesResponse) GetId() string

func (*ChangeNumberOfVehiclesResponse) GetNumberOfVehicles 

func (x *ChangeNumberOfVehiclesResponse) GetNumberOfVehicles() int32

func (*ChangeNumberOfVehiclesResponse) ProtoMessage 

func (*ChangeNumberOfVehiclesResponse) ProtoMessage()

func (*ChangeNumberOfVehiclesResponse) ProtoReflect 

func (x *ChangeNumberOfVehiclesResponse) ProtoReflect() protoreflect.Message

func (*ChangeNumberOfVehiclesResponse) Reset 

func (x *ChangeNumberOfVehiclesResponse) Reset()

func (*ChangeNumberOfVehiclesResponse) String 

func (x *ChangeNumberOfVehiclesResponse) String() string

type CommandType 

type CommandType int32
const (
	CommandType_ARM     CommandType = 0
	CommandType_DISARM  CommandType = 1
	CommandType_UPLOAD  CommandType = 2
	CommandType_START   CommandType = 3
	CommandType_PAUSE   CommandType = 4
	CommandType_TAKEOFF CommandType = 5
	CommandType_LAND    CommandType = 6
	CommandType_RETURN  CommandType = 7
	CommandType_NONE    CommandType = 99
)

func (CommandType) Descriptor 

func (CommandType) Descriptor() protoreflect.EnumDescriptor

func (CommandType) Enum 

func (x CommandType) Enum() *CommandType

func (CommandType) EnumDescriptor deprecated 

func (CommandType) EnumDescriptor() ([]byte, []int)

Deprecated: Use CommandType.Descriptor instead.

func (CommandType) Number 

func (x CommandType) Number() protoreflect.EnumNumber

func (CommandType) String 

func (x CommandType) String() string

func (CommandType) Type 

func (CommandType) Type() protoreflect.EnumType

type CommunicationEdgeServiceClient 

type CommunicationEdgeServiceClient interface {
	PushTelemetry(ctx context.Context, in *PushTelemetryRequest, opts ...grpc.CallOption) (*PushTelemetryResponse, error)
	PullCommand(ctx context.Context, in *PullCommandRequest, opts ...grpc.CallOption) (*PullCommandResponse, error)
	PullUploadMission(ctx context.Context, in *PullUploadMissionRequest, opts ...grpc.CallOption) (*PullUploadMissionResponse, error)
}

CommunicationEdgeServiceClient is the client API for CommunicationEdgeService 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.

func NewCommunicationEdgeServiceClient 

func NewCommunicationEdgeServiceClient(cc grpc.ClientConnInterface) CommunicationEdgeServiceClient

type CommunicationEdgeServiceServer 

type CommunicationEdgeServiceServer interface {
	PushTelemetry(context.Context, *PushTelemetryRequest) (*PushTelemetryResponse, error)
	PullCommand(context.Context, *PullCommandRequest) (*PullCommandResponse, error)
	PullUploadMission(context.Context, *PullUploadMissionRequest) (*PullUploadMissionResponse, error)
	// contains filtered or unexported methods
}

CommunicationEdgeServiceServer is the server API for CommunicationEdgeService service. All implementations must embed UnimplementedCommunicationEdgeServiceServer for forward compatibility

type CommunicationIdGaveEvent 

type CommunicationIdGaveEvent struct {
	CommunicationId string `protobuf:"bytes,1,opt,name=communication_id,json=communicationId,proto3" json:"communication_id,omitempty"`
	// contains filtered or unexported fields
}

func (*CommunicationIdGaveEvent) Descriptor deprecated 

func (*CommunicationIdGaveEvent) Descriptor() ([]byte, []int)

Deprecated: Use CommunicationIdGaveEvent.ProtoReflect.Descriptor instead.

func (*CommunicationIdGaveEvent) GetCommunicationId 

func (x *CommunicationIdGaveEvent) GetCommunicationId() string

func (*CommunicationIdGaveEvent) ProtoMessage 

func (*CommunicationIdGaveEvent) ProtoMessage()

func (*CommunicationIdGaveEvent) ProtoReflect 

func (x *CommunicationIdGaveEvent) ProtoReflect() protoreflect.Message

func (*CommunicationIdGaveEvent) Reset 

func (x *CommunicationIdGaveEvent) Reset()

func (*CommunicationIdGaveEvent) String 

func (x *CommunicationIdGaveEvent) String() string

type CommunicationIdRemovedEvent 

type CommunicationIdRemovedEvent struct {
	CommunicationId string `protobuf:"bytes,1,opt,name=communication_id,json=communicationId,proto3" json:"communication_id,omitempty"`
	// contains filtered or unexported fields
}

func (*CommunicationIdRemovedEvent) Descriptor deprecated 

func (*CommunicationIdRemovedEvent) Descriptor() ([]byte, []int)

Deprecated: Use CommunicationIdRemovedEvent.ProtoReflect.Descriptor instead.

func (*CommunicationIdRemovedEvent) GetCommunicationId 

func (x *CommunicationIdRemovedEvent) GetCommunicationId() string

func (*CommunicationIdRemovedEvent) ProtoMessage 

func (*CommunicationIdRemovedEvent) ProtoMessage()

func (*CommunicationIdRemovedEvent) ProtoReflect 

func (x *CommunicationIdRemovedEvent) ProtoReflect() protoreflect.Message

func (*CommunicationIdRemovedEvent) Reset 

func (x *CommunicationIdRemovedEvent) Reset()

func (*CommunicationIdRemovedEvent) String 

func (x *CommunicationIdRemovedEvent) String() string

type CommunicationUserServiceClient 

type CommunicationUserServiceClient interface {
	PushCommand(ctx context.Context, in *PushCommandRequest, opts ...grpc.CallOption) (*PushCommandResponse, error)
	PushUploadMission(ctx context.Context, in *PushUploadMissionRequest, opts ...grpc.CallOption) (*PushUploadMissionResponse, error)
	PullTelemetry(ctx context.Context, in *PullTelemetryRequest, opts ...grpc.CallOption) (*PullTelemetryResponse, error)
}

CommunicationUserServiceClient is the client API for CommunicationUserService 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.

func NewCommunicationUserServiceClient 

func NewCommunicationUserServiceClient(cc grpc.ClientConnInterface) CommunicationUserServiceClient

type CommunicationUserServiceServer 

type CommunicationUserServiceServer interface {
	PushCommand(context.Context, *PushCommandRequest) (*PushCommandResponse, error)
	PushUploadMission(context.Context, *PushUploadMissionRequest) (*PushUploadMissionResponse, error)
	PullTelemetry(context.Context, *PullTelemetryRequest) (*PullTelemetryResponse, error)
	// contains filtered or unexported methods
}

CommunicationUserServiceServer is the server API for CommunicationUserService service. All implementations must embed UnimplementedCommunicationUserServiceServer for forward compatibility

type CompleteFlightoperationRequest 

type CompleteFlightoperationRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*CompleteFlightoperationRequest) Descriptor deprecated 

func (*CompleteFlightoperationRequest) Descriptor() ([]byte, []int)

Deprecated: Use CompleteFlightoperationRequest.ProtoReflect.Descriptor instead.

func (*CompleteFlightoperationRequest) GetId 

func (x *CompleteFlightoperationRequest) GetId() string

func (*CompleteFlightoperationRequest) ProtoMessage 

func (*CompleteFlightoperationRequest) ProtoMessage()

func (*CompleteFlightoperationRequest) ProtoReflect 

func (x *CompleteFlightoperationRequest) ProtoReflect() protoreflect.Message

func (*CompleteFlightoperationRequest) Reset 

func (x *CompleteFlightoperationRequest) Reset()

func (*CompleteFlightoperationRequest) String 

func (x *CompleteFlightoperationRequest) String() string

type CopiedMissionCreatedEvent 

type CopiedMissionCreatedEvent struct {
	MissionId string   `protobuf:"bytes,1,opt,name=mission_id,json=missionId,proto3" json:"mission_id,omitempty"`
	Mission   *Mission `protobuf:"bytes,2,opt,name=mission,proto3" json:"mission,omitempty"`
	// contains filtered or unexported fields
}

func (*CopiedMissionCreatedEvent) Descriptor deprecated 

func (*CopiedMissionCreatedEvent) Descriptor() ([]byte, []int)

Deprecated: Use CopiedMissionCreatedEvent.ProtoReflect.Descriptor instead.

func (*CopiedMissionCreatedEvent) GetMission 

func (x *CopiedMissionCreatedEvent) GetMission() *Mission

func (*CopiedMissionCreatedEvent) GetMissionId 

func (x *CopiedMissionCreatedEvent) GetMissionId() string

func (*CopiedMissionCreatedEvent) ProtoMessage 

func (*CopiedMissionCreatedEvent) ProtoMessage()

func (*CopiedMissionCreatedEvent) ProtoReflect 

func (x *CopiedMissionCreatedEvent) ProtoReflect() protoreflect.Message

func (*CopiedMissionCreatedEvent) Reset 

func (x *CopiedMissionCreatedEvent) Reset()

func (*CopiedMissionCreatedEvent) String 

func (x *CopiedMissionCreatedEvent) String() string

type CopiedVehicleCreatedEvent 

type CopiedVehicleCreatedEvent struct {
	VehicleId       string `protobuf:"bytes,1,opt,name=vehicle_id,json=vehicleId,proto3" json:"vehicle_id,omitempty"`
	CommunicationId string `protobuf:"bytes,2,opt,name=communication_id,json=communicationId,proto3" json:"communication_id,omitempty"`
	FleetId         string `protobuf:"bytes,3,opt,name=fleet_id,json=fleetId,proto3" json:"fleet_id,omitempty"`
	// contains filtered or unexported fields
}

func (*CopiedVehicleCreatedEvent) Descriptor deprecated 

func (*CopiedVehicleCreatedEvent) Descriptor() ([]byte, []int)

Deprecated: Use CopiedVehicleCreatedEvent.ProtoReflect.Descriptor instead.

func (*CopiedVehicleCreatedEvent) GetCommunicationId 

func (x *CopiedVehicleCreatedEvent) GetCommunicationId() string

func (*CopiedVehicleCreatedEvent) GetFleetId 

func (x *CopiedVehicleCreatedEvent) GetFleetId() string

func (*CopiedVehicleCreatedEvent) GetVehicleId 

func (x *CopiedVehicleCreatedEvent) GetVehicleId() string

func (*CopiedVehicleCreatedEvent) ProtoMessage 

func (*CopiedVehicleCreatedEvent) ProtoMessage()

func (*CopiedVehicleCreatedEvent) ProtoReflect 

func (x *CopiedVehicleCreatedEvent) ProtoReflect() protoreflect.Message

func (*CopiedVehicleCreatedEvent) Reset 

func (x *CopiedVehicleCreatedEvent) Reset()

func (*CopiedVehicleCreatedEvent) String 

func (x *CopiedVehicleCreatedEvent) String() string

type DeleteFlightplanRequest 

type DeleteFlightplanRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteFlightplanRequest) Descriptor deprecated 

func (*DeleteFlightplanRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteFlightplanRequest.ProtoReflect.Descriptor instead.

func (*DeleteFlightplanRequest) GetId 

func (x *DeleteFlightplanRequest) GetId() string

func (*DeleteFlightplanRequest) ProtoMessage 

func (*DeleteFlightplanRequest) ProtoMessage()

func (*DeleteFlightplanRequest) ProtoReflect 

func (x *DeleteFlightplanRequest) ProtoReflect() protoreflect.Message

func (*DeleteFlightplanRequest) Reset 

func (x *DeleteFlightplanRequest) Reset()

func (*DeleteFlightplanRequest) String 

func (x *DeleteFlightplanRequest) String() string

type DeleteMissionRequest 

type DeleteMissionRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteMissionRequest) Descriptor deprecated 

func (*DeleteMissionRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteMissionRequest.ProtoReflect.Descriptor instead.

func (*DeleteMissionRequest) GetId 

func (x *DeleteMissionRequest) GetId() string

func (*DeleteMissionRequest) ProtoMessage 

func (*DeleteMissionRequest) ProtoMessage()

func (*DeleteMissionRequest) ProtoReflect 

func (x *DeleteMissionRequest) ProtoReflect() protoreflect.Message

func (*DeleteMissionRequest) Reset 

func (x *DeleteMissionRequest) Reset()

func (*DeleteMissionRequest) String 

func (x *DeleteMissionRequest) String() string

type DeleteVehicleRequest 

type DeleteVehicleRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteVehicleRequest) Descriptor deprecated 

func (*DeleteVehicleRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteVehicleRequest.ProtoReflect.Descriptor instead.

func (*DeleteVehicleRequest) GetId 

func (x *DeleteVehicleRequest) GetId() string

func (*DeleteVehicleRequest) ProtoMessage 

func (*DeleteVehicleRequest) ProtoMessage()

func (*DeleteVehicleRequest) ProtoReflect 

func (x *DeleteVehicleRequest) ProtoReflect() protoreflect.Message

func (*DeleteVehicleRequest) Reset 

func (x *DeleteVehicleRequest) Reset()

func (*DeleteVehicleRequest) String 

func (x *DeleteVehicleRequest) String() string

type Empty 

type Empty struct {
	// contains filtered or unexported fields
}

func (*Empty) Descriptor deprecated 

func (*Empty) Descriptor() ([]byte, []int)

Deprecated: Use Empty.ProtoReflect.Descriptor instead.

func (*Empty) ProtoMessage 

func (*Empty) ProtoMessage()

func (*Empty) ProtoReflect 

func (x *Empty) ProtoReflect() protoreflect.Message

func (*Empty) Reset 

func (x *Empty) Reset()

func (*Empty) String 

func (x *Empty) String() string

type ExecuteFlightplanRequest 

type ExecuteFlightplanRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*ExecuteFlightplanRequest) Descriptor deprecated 

func (*ExecuteFlightplanRequest) Descriptor() ([]byte, []int)

Deprecated: Use ExecuteFlightplanRequest.ProtoReflect.Descriptor instead.

func (*ExecuteFlightplanRequest) GetId 

func (x *ExecuteFlightplanRequest) GetId() string

func (*ExecuteFlightplanRequest) ProtoMessage 

func (*ExecuteFlightplanRequest) ProtoMessage()

func (*ExecuteFlightplanRequest) ProtoReflect 

func (x *ExecuteFlightplanRequest) ProtoReflect() protoreflect.Message

func (*ExecuteFlightplanRequest) Reset 

func (x *ExecuteFlightplanRequest) Reset()

func (*ExecuteFlightplanRequest) String 

func (x *ExecuteFlightplanRequest) String() string

type ExecuteFlightplanResponse 

type ExecuteFlightplanResponse struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*ExecuteFlightplanResponse) Descriptor deprecated 

func (*ExecuteFlightplanResponse) Descriptor() ([]byte, []int)

Deprecated: Use ExecuteFlightplanResponse.ProtoReflect.Descriptor instead.

func (*ExecuteFlightplanResponse) GetId 

func (x *ExecuteFlightplanResponse) GetId() string

func (*ExecuteFlightplanResponse) ProtoMessage 

func (*ExecuteFlightplanResponse) ProtoMessage()

func (*ExecuteFlightplanResponse) ProtoReflect 

func (x *ExecuteFlightplanResponse) ProtoReflect() protoreflect.Message

func (*ExecuteFlightplanResponse) Reset 

func (x *ExecuteFlightplanResponse) Reset()

func (*ExecuteFlightplanResponse) String 

func (x *ExecuteFlightplanResponse) String() string

type ExecuteFlightplanServiceClient 

type ExecuteFlightplanServiceClient interface {
	ExecuteFlightplan(ctx context.Context, in *ExecuteFlightplanRequest, opts ...grpc.CallOption) (*ExecuteFlightplanResponse, error)
}

ExecuteFlightplanServiceClient is the client API for ExecuteFlightplanService 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.

func NewExecuteFlightplanServiceClient 

func NewExecuteFlightplanServiceClient(cc grpc.ClientConnInterface) ExecuteFlightplanServiceClient

type ExecuteFlightplanServiceServer 

type ExecuteFlightplanServiceServer interface {
	ExecuteFlightplan(context.Context, *ExecuteFlightplanRequest) (*ExecuteFlightplanResponse, error)
	// contains filtered or unexported methods
}

ExecuteFlightplanServiceServer is the server API for ExecuteFlightplanService service. All implementations must embed UnimplementedExecuteFlightplanServiceServer for forward compatibility

type FleetCopiedEvent 

type FleetCopiedEvent struct {
	OriginalFleetId string `protobuf:"bytes,1,opt,name=original_fleet_id,json=originalFleetId,proto3" json:"original_fleet_id,omitempty"`
	NewFleetId      string `protobuf:"bytes,2,opt,name=new_fleet_id,json=newFleetId,proto3" json:"new_fleet_id,omitempty"`
	// contains filtered or unexported fields
}

func (*FleetCopiedEvent) Descriptor deprecated 

func (*FleetCopiedEvent) Descriptor() ([]byte, []int)

Deprecated: Use FleetCopiedEvent.ProtoReflect.Descriptor instead.

func (*FleetCopiedEvent) GetNewFleetId 

func (x *FleetCopiedEvent) GetNewFleetId() string

func (*FleetCopiedEvent) GetOriginalFleetId 

func (x *FleetCopiedEvent) GetOriginalFleetId() string

func (*FleetCopiedEvent) ProtoMessage 

func (*FleetCopiedEvent) ProtoMessage()

func (*FleetCopiedEvent) ProtoReflect 

func (x *FleetCopiedEvent) ProtoReflect() protoreflect.Message

func (*FleetCopiedEvent) Reset 

func (x *FleetCopiedEvent) Reset()

func (*FleetCopiedEvent) String 

func (x *FleetCopiedEvent) String() string

type FleetIDGaveEvent 

type FleetIDGaveEvent struct {
	FleetId          string `protobuf:"bytes,1,opt,name=fleet_id,json=fleetId,proto3" json:"fleet_id,omitempty"`
	NumberOfVehicles int32  `protobuf:"varint,2,opt,name=number_of_vehicles,json=numberOfVehicles,proto3" json:"number_of_vehicles,omitempty"`
	// contains filtered or unexported fields
}

func (*FleetIDGaveEvent) Descriptor deprecated 

func (*FleetIDGaveEvent) Descriptor() ([]byte, []int)

Deprecated: Use FleetIDGaveEvent.ProtoReflect.Descriptor instead.

func (*FleetIDGaveEvent) GetFleetId 

func (x *FleetIDGaveEvent) GetFleetId() string

func (*FleetIDGaveEvent) GetNumberOfVehicles 

func (x *FleetIDGaveEvent) GetNumberOfVehicles() int32

func (*FleetIDGaveEvent) ProtoMessage 

func (*FleetIDGaveEvent) ProtoMessage()

func (*FleetIDGaveEvent) ProtoReflect 

func (x *FleetIDGaveEvent) ProtoReflect() protoreflect.Message

func (*FleetIDGaveEvent) Reset 

func (x *FleetIDGaveEvent) Reset()

func (*FleetIDGaveEvent) String 

func (x *FleetIDGaveEvent) String() string

type FleetIDRemovedEvent 

type FleetIDRemovedEvent struct {
	FleetId string `protobuf:"bytes,1,opt,name=fleet_id,json=fleetId,proto3" json:"fleet_id,omitempty"`
	// contains filtered or unexported fields
}

func (*FleetIDRemovedEvent) Descriptor deprecated 

func (*FleetIDRemovedEvent) Descriptor() ([]byte, []int)

Deprecated: Use FleetIDRemovedEvent.ProtoReflect.Descriptor instead.

func (*FleetIDRemovedEvent) GetFleetId 

func (x *FleetIDRemovedEvent) GetFleetId() string

func (*FleetIDRemovedEvent) ProtoMessage 

func (*FleetIDRemovedEvent) ProtoMessage()

func (*FleetIDRemovedEvent) ProtoReflect 

func (x *FleetIDRemovedEvent) ProtoReflect() protoreflect.Message

func (*FleetIDRemovedEvent) Reset 

func (x *FleetIDRemovedEvent) Reset()

func (*FleetIDRemovedEvent) String 

func (x *FleetIDRemovedEvent) String() string

type Flightoperation 

type Flightoperation struct {
	Id          string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name        string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	FleetId     string `protobuf:"bytes,4,opt,name=fleet_id,json=fleetId,proto3" json:"fleet_id,omitempty"`
	// contains filtered or unexported fields
}

func (*Flightoperation) Descriptor deprecated 

func (*Flightoperation) Descriptor() ([]byte, []int)

Deprecated: Use Flightoperation.ProtoReflect.Descriptor instead.

func (*Flightoperation) GetDescription 

func (x *Flightoperation) GetDescription() string

func (*Flightoperation) GetFleetId 

func (x *Flightoperation) GetFleetId() string

func (*Flightoperation) GetId 

func (x *Flightoperation) GetId() string

func (*Flightoperation) GetName 

func (x *Flightoperation) GetName() string

func (*Flightoperation) ProtoMessage 

func (*Flightoperation) ProtoMessage()

func (*Flightoperation) ProtoReflect 

func (x *Flightoperation) ProtoReflect() protoreflect.Message

func (*Flightoperation) Reset 

func (x *Flightoperation) Reset()

func (*Flightoperation) String 

func (x *Flightoperation) String() string

type FlightoperationCompletedEvent 

type FlightoperationCompletedEvent struct {
	FlightoperationId string           `protobuf:"bytes,1,opt,name=flightoperation_id,json=flightoperationId,proto3" json:"flightoperation_id,omitempty"`
	Flightoperation   *Flightoperation `protobuf:"bytes,2,opt,name=flightoperation,proto3" json:"flightoperation,omitempty"`
	// contains filtered or unexported fields
}

func (*FlightoperationCompletedEvent) Descriptor deprecated 

func (*FlightoperationCompletedEvent) Descriptor() ([]byte, []int)

Deprecated: Use FlightoperationCompletedEvent.ProtoReflect.Descriptor instead.

func (*FlightoperationCompletedEvent) GetFlightoperation 

func (x *FlightoperationCompletedEvent) GetFlightoperation() *Flightoperation

func (*FlightoperationCompletedEvent) GetFlightoperationId 

func (x *FlightoperationCompletedEvent) GetFlightoperationId() string

func (*FlightoperationCompletedEvent) ProtoMessage 

func (*FlightoperationCompletedEvent) ProtoMessage()

func (*FlightoperationCompletedEvent) ProtoReflect 

func (x *FlightoperationCompletedEvent) ProtoReflect() protoreflect.Message

func (*FlightoperationCompletedEvent) Reset 

func (x *FlightoperationCompletedEvent) Reset()

func (*FlightoperationCompletedEvent) String 

func (x *FlightoperationCompletedEvent) String() string

type Flightplan 

type Flightplan struct {
	Id          string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name        string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	FleetId     string `protobuf:"bytes,4,opt,name=fleet_id,json=fleetId,proto3" json:"fleet_id,omitempty"`
	// contains filtered or unexported fields
}

func (*Flightplan) Descriptor deprecated 

func (*Flightplan) Descriptor() ([]byte, []int)

Deprecated: Use Flightplan.ProtoReflect.Descriptor instead.

func (*Flightplan) GetDescription 

func (x *Flightplan) GetDescription() string

func (*Flightplan) GetFleetId 

func (x *Flightplan) GetFleetId() string

func (*Flightplan) GetId 

func (x *Flightplan) GetId() string

func (*Flightplan) GetName 

func (x *Flightplan) GetName() string

func (*Flightplan) ProtoMessage 

func (*Flightplan) ProtoMessage()

func (*Flightplan) ProtoReflect 

func (x *Flightplan) ProtoReflect() protoreflect.Message

func (*Flightplan) Reset 

func (x *Flightplan) Reset()

func (*Flightplan) String 

func (x *Flightplan) String() string

type FlightplanExecutedEvent 

type FlightplanExecutedEvent struct {
	FlightplanId string      `protobuf:"bytes,1,opt,name=flightplan_id,json=flightplanId,proto3" json:"flightplan_id,omitempty"`
	Flightplan   *Flightplan `protobuf:"bytes,2,opt,name=flightplan,proto3" json:"flightplan,omitempty"`
	// contains filtered or unexported fields
}

func (*FlightplanExecutedEvent) Descriptor deprecated 

func (*FlightplanExecutedEvent) Descriptor() ([]byte, []int)

Deprecated: Use FlightplanExecutedEvent.ProtoReflect.Descriptor instead.

func (*FlightplanExecutedEvent) GetFlightplan 

func (x *FlightplanExecutedEvent) GetFlightplan() *Flightplan

func (*FlightplanExecutedEvent) GetFlightplanId 

func (x *FlightplanExecutedEvent) GetFlightplanId() string

func (*FlightplanExecutedEvent) ProtoMessage 

func (*FlightplanExecutedEvent) ProtoMessage()

func (*FlightplanExecutedEvent) ProtoReflect 

func (x *FlightplanExecutedEvent) ProtoReflect() protoreflect.Message

func (*FlightplanExecutedEvent) Reset 

func (x *FlightplanExecutedEvent) Reset()

func (*FlightplanExecutedEvent) String 

func (x *FlightplanExecutedEvent) String() string

type Flightreport 

type Flightreport struct {
	Id          string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name        string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	FleetId     string `protobuf:"bytes,4,opt,name=fleet_id,json=fleetId,proto3" json:"fleet_id,omitempty"`
	// contains filtered or unexported fields
}

func (*Flightreport) Descriptor deprecated 

func (*Flightreport) Descriptor() ([]byte, []int)

Deprecated: Use Flightreport.ProtoReflect.Descriptor instead.

func (*Flightreport) GetDescription 

func (x *Flightreport) GetDescription() string

func (*Flightreport) GetFleetId 

func (x *Flightreport) GetFleetId() string

func (*Flightreport) GetId 

func (x *Flightreport) GetId() string

func (*Flightreport) GetName 

func (x *Flightreport) GetName() string

func (*Flightreport) ProtoMessage 

func (*Flightreport) ProtoMessage()

func (*Flightreport) ProtoReflect 

func (x *Flightreport) ProtoReflect() protoreflect.Message

func (*Flightreport) Reset 

func (x *Flightreport) Reset()

func (*Flightreport) String 

func (x *Flightreport) String() string

type GetAssignmentsRequest 

type GetAssignmentsRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*GetAssignmentsRequest) Descriptor deprecated 

func (*GetAssignmentsRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetAssignmentsRequest.ProtoReflect.Descriptor instead.

func (*GetAssignmentsRequest) GetId 

func (x *GetAssignmentsRequest) GetId() string

func (*GetAssignmentsRequest) ProtoMessage 

func (*GetAssignmentsRequest) ProtoMessage()

func (*GetAssignmentsRequest) ProtoReflect 

func (x *GetAssignmentsRequest) ProtoReflect() protoreflect.Message

func (*GetAssignmentsRequest) Reset 

func (x *GetAssignmentsRequest) Reset()

func (*GetAssignmentsRequest) String 

func (x *GetAssignmentsRequest) String() string

type GetAssignmentsResponse 

type GetAssignmentsResponse struct {
	Id          string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Assignments []*Assignment `protobuf:"bytes,2,rep,name=assignments,proto3" json:"assignments,omitempty"`
	// contains filtered or unexported fields
}

func (*GetAssignmentsResponse) Descriptor deprecated 

func (*GetAssignmentsResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetAssignmentsResponse.ProtoReflect.Descriptor instead.

func (*GetAssignmentsResponse) GetAssignments 

func (x *GetAssignmentsResponse) GetAssignments() []*Assignment

func (*GetAssignmentsResponse) GetId 

func (x *GetAssignmentsResponse) GetId() string

func (*GetAssignmentsResponse) ProtoMessage 

func (*GetAssignmentsResponse) ProtoMessage()

func (*GetAssignmentsResponse) ProtoReflect 

func (x *GetAssignmentsResponse) ProtoReflect() protoreflect.Message

func (*GetAssignmentsResponse) Reset 

func (x *GetAssignmentsResponse) Reset()

func (*GetAssignmentsResponse) String 

func (x *GetAssignmentsResponse) String() string

type GetEllipsoidHeightRequest 

type GetEllipsoidHeightRequest struct {
	Latitude  float64 `protobuf:"fixed64,1,opt,name=latitude,proto3" json:"latitude,omitempty"`
	Longitude float64 `protobuf:"fixed64,2,opt,name=longitude,proto3" json:"longitude,omitempty"`
	// contains filtered or unexported fields
}

func (*GetEllipsoidHeightRequest) Descriptor deprecated 

func (*GetEllipsoidHeightRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetEllipsoidHeightRequest.ProtoReflect.Descriptor instead.

func (*GetEllipsoidHeightRequest) GetLatitude 

func (x *GetEllipsoidHeightRequest) GetLatitude() float64

func (*GetEllipsoidHeightRequest) GetLongitude 

func (x *GetEllipsoidHeightRequest) GetLongitude() float64

func (*GetEllipsoidHeightRequest) ProtoMessage 

func (*GetEllipsoidHeightRequest) ProtoMessage()

func (*GetEllipsoidHeightRequest) ProtoReflect 

func (x *GetEllipsoidHeightRequest) ProtoReflect() protoreflect.Message

func (*GetEllipsoidHeightRequest) Reset 

func (x *GetEllipsoidHeightRequest) Reset()

func (*GetEllipsoidHeightRequest) String 

func (x *GetEllipsoidHeightRequest) String() string

type GetEllipsoidHeightResponse 

type GetEllipsoidHeightResponse struct {
	Height float64 `protobuf:"fixed64,1,opt,name=height,proto3" json:"height,omitempty"`
	// contains filtered or unexported fields
}

func (*GetEllipsoidHeightResponse) Descriptor deprecated 

func (*GetEllipsoidHeightResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetEllipsoidHeightResponse.ProtoReflect.Descriptor instead.

func (*GetEllipsoidHeightResponse) GetHeight 

func (x *GetEllipsoidHeightResponse) GetHeight() float64

func (*GetEllipsoidHeightResponse) ProtoMessage 

func (*GetEllipsoidHeightResponse) ProtoMessage()

func (*GetEllipsoidHeightResponse) ProtoReflect 

func (x *GetEllipsoidHeightResponse) ProtoReflect() protoreflect.Message

func (*GetEllipsoidHeightResponse) Reset 

func (x *GetEllipsoidHeightResponse) Reset()

func (*GetEllipsoidHeightResponse) String 

func (x *GetEllipsoidHeightResponse) String() string

type GetFlightoperationRequest 

type GetFlightoperationRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*GetFlightoperationRequest) Descriptor deprecated 

func (*GetFlightoperationRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetFlightoperationRequest.ProtoReflect.Descriptor instead.

func (*GetFlightoperationRequest) GetId 

func (x *GetFlightoperationRequest) GetId() string

func (*GetFlightoperationRequest) ProtoMessage 

func (*GetFlightoperationRequest) ProtoMessage()

func (*GetFlightoperationRequest) ProtoReflect 

func (x *GetFlightoperationRequest) ProtoReflect() protoreflect.Message

func (*GetFlightoperationRequest) Reset 

func (x *GetFlightoperationRequest) Reset()

func (*GetFlightoperationRequest) String 

func (x *GetFlightoperationRequest) String() string

type GetFlightplanRequest 

type GetFlightplanRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*GetFlightplanRequest) Descriptor deprecated 

func (*GetFlightplanRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetFlightplanRequest.ProtoReflect.Descriptor instead.

func (*GetFlightplanRequest) GetId 

func (x *GetFlightplanRequest) GetId() string

func (*GetFlightplanRequest) ProtoMessage 

func (*GetFlightplanRequest) ProtoMessage()

func (*GetFlightplanRequest) ProtoReflect 

func (x *GetFlightplanRequest) ProtoReflect() protoreflect.Message

func (*GetFlightplanRequest) Reset 

func (x *GetFlightplanRequest) Reset()

func (*GetFlightplanRequest) String 

func (x *GetFlightplanRequest) String() string

type GetFlightreportRequest 

type GetFlightreportRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*GetFlightreportRequest) Descriptor deprecated 

func (*GetFlightreportRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetFlightreportRequest.ProtoReflect.Descriptor instead.

func (*GetFlightreportRequest) GetId 

func (x *GetFlightreportRequest) GetId() string

func (*GetFlightreportRequest) ProtoMessage 

func (*GetFlightreportRequest) ProtoMessage()

func (*GetFlightreportRequest) ProtoReflect 

func (x *GetFlightreportRequest) ProtoReflect() protoreflect.Message

func (*GetFlightreportRequest) Reset 

func (x *GetFlightreportRequest) Reset()

func (*GetFlightreportRequest) String 

func (x *GetFlightreportRequest) String() string

type GetMissionRequest 

type GetMissionRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*GetMissionRequest) Descriptor deprecated 

func (*GetMissionRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetMissionRequest.ProtoReflect.Descriptor instead.

func (*GetMissionRequest) GetId 

func (x *GetMissionRequest) GetId() string

func (*GetMissionRequest) ProtoMessage 

func (*GetMissionRequest) ProtoMessage()

func (*GetMissionRequest) ProtoReflect 

func (x *GetMissionRequest) ProtoReflect() protoreflect.Message

func (*GetMissionRequest) Reset 

func (x *GetMissionRequest) Reset()

func (*GetMissionRequest) String 

func (x *GetMissionRequest) String() string

type GetTrajectoryRequest 

type GetTrajectoryRequest struct {
	VehicleId string `protobuf:"bytes,1,opt,name=vehicle_id,json=vehicleId,proto3" json:"vehicle_id,omitempty"`
	// contains filtered or unexported fields
}

func (*GetTrajectoryRequest) Descriptor deprecated 

func (*GetTrajectoryRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetTrajectoryRequest.ProtoReflect.Descriptor instead.

func (*GetTrajectoryRequest) GetVehicleId 

func (x *GetTrajectoryRequest) GetVehicleId() string

func (*GetTrajectoryRequest) ProtoMessage 

func (*GetTrajectoryRequest) ProtoMessage()

func (*GetTrajectoryRequest) ProtoReflect 

func (x *GetTrajectoryRequest) ProtoReflect() protoreflect.Message

func (*GetTrajectoryRequest) Reset 

func (x *GetTrajectoryRequest) Reset()

func (*GetTrajectoryRequest) String 

func (x *GetTrajectoryRequest) String() string

type GetTrajectoryResponse 

type GetTrajectoryResponse struct {
	Telemetries []*Telemetry `protobuf:"bytes,1,rep,name=telemetries,proto3" json:"telemetries,omitempty"`
	// contains filtered or unexported fields
}

func (*GetTrajectoryResponse) Descriptor deprecated 

func (*GetTrajectoryResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetTrajectoryResponse.ProtoReflect.Descriptor instead.

func (*GetTrajectoryResponse) GetTelemetries 

func (x *GetTrajectoryResponse) GetTelemetries() []*Telemetry

func (*GetTrajectoryResponse) ProtoMessage 

func (*GetTrajectoryResponse) ProtoMessage()

func (*GetTrajectoryResponse) ProtoReflect 

func (x *GetTrajectoryResponse) ProtoReflect() protoreflect.Message

func (*GetTrajectoryResponse) Reset 

func (x *GetTrajectoryResponse) Reset()

func (*GetTrajectoryResponse) String 

func (x *GetTrajectoryResponse) String() string

type GetUploadMissionRequest 

type GetUploadMissionRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*GetUploadMissionRequest) Descriptor deprecated 

func (*GetUploadMissionRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetUploadMissionRequest.ProtoReflect.Descriptor instead.

func (*GetUploadMissionRequest) GetId 

func (x *GetUploadMissionRequest) GetId() string

func (*GetUploadMissionRequest) ProtoMessage 

func (*GetUploadMissionRequest) ProtoMessage()

func (*GetUploadMissionRequest) ProtoReflect 

func (x *GetUploadMissionRequest) ProtoReflect() protoreflect.Message

func (*GetUploadMissionRequest) Reset 

func (x *GetUploadMissionRequest) Reset()

func (*GetUploadMissionRequest) String 

func (x *GetUploadMissionRequest) String() string

type GetVehicleRequest 

type GetVehicleRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*GetVehicleRequest) Descriptor deprecated 

func (*GetVehicleRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetVehicleRequest.ProtoReflect.Descriptor instead.

func (*GetVehicleRequest) GetId 

func (x *GetVehicleRequest) GetId() string

func (*GetVehicleRequest) ProtoMessage 

func (*GetVehicleRequest) ProtoMessage()

func (*GetVehicleRequest) ProtoReflect 

func (x *GetVehicleRequest) ProtoReflect() protoreflect.Message

func (*GetVehicleRequest) Reset 

func (x *GetVehicleRequest) Reset()

func (*GetVehicleRequest) String 

func (x *GetVehicleRequest) String() string

type HelperUserServiceClient 

type HelperUserServiceClient interface {
	GetEllipsoidHeight(ctx context.Context, in *GetEllipsoidHeightRequest, opts ...grpc.CallOption) (*GetEllipsoidHeightResponse, error)
}

HelperUserServiceClient is the client API for HelperUserService 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.

func NewHelperUserServiceClient 

func NewHelperUserServiceClient(cc grpc.ClientConnInterface) HelperUserServiceClient

type HelperUserServiceServer 

type HelperUserServiceServer interface {
	GetEllipsoidHeight(context.Context, *GetEllipsoidHeightRequest) (*GetEllipsoidHeightResponse, error)
	// contains filtered or unexported methods
}

HelperUserServiceServer is the server API for HelperUserService service. All implementations must embed UnimplementedHelperUserServiceServer for forward compatibility

type ListFlightoperationsResponses 

type ListFlightoperationsResponses struct {
	Flightoperations []*Flightoperation `protobuf:"bytes,1,rep,name=flightoperations,proto3" json:"flightoperations,omitempty"`
	// contains filtered or unexported fields
}

func (*ListFlightoperationsResponses) Descriptor deprecated 

func (*ListFlightoperationsResponses) Descriptor() ([]byte, []int)

Deprecated: Use ListFlightoperationsResponses.ProtoReflect.Descriptor instead.

func (*ListFlightoperationsResponses) GetFlightoperations 

func (x *ListFlightoperationsResponses) GetFlightoperations() []*Flightoperation

func (*ListFlightoperationsResponses) ProtoMessage 

func (*ListFlightoperationsResponses) ProtoMessage()

func (*ListFlightoperationsResponses) ProtoReflect 

func (x *ListFlightoperationsResponses) ProtoReflect() protoreflect.Message

func (*ListFlightoperationsResponses) Reset 

func (x *ListFlightoperationsResponses) Reset()

func (*ListFlightoperationsResponses) String 

func (x *ListFlightoperationsResponses) String() string

type ListFlightplansResponses 

type ListFlightplansResponses struct {
	Flightplans []*Flightplan `protobuf:"bytes,1,rep,name=flightplans,proto3" json:"flightplans,omitempty"`
	// contains filtered or unexported fields
}

func (*ListFlightplansResponses) Descriptor deprecated 

func (*ListFlightplansResponses) Descriptor() ([]byte, []int)

Deprecated: Use ListFlightplansResponses.ProtoReflect.Descriptor instead.

func (*ListFlightplansResponses) GetFlightplans 

func (x *ListFlightplansResponses) GetFlightplans() []*Flightplan

func (*ListFlightplansResponses) ProtoMessage 

func (*ListFlightplansResponses) ProtoMessage()

func (*ListFlightplansResponses) ProtoReflect 

func (x *ListFlightplansResponses) ProtoReflect() protoreflect.Message

func (*ListFlightplansResponses) Reset 

func (x *ListFlightplansResponses) Reset()

func (*ListFlightplansResponses) String 

func (x *ListFlightplansResponses) String() string

type ListFlightreportsResponses 

type ListFlightreportsResponses struct {
	Flightreports []*Flightreport `protobuf:"bytes,1,rep,name=flightreports,proto3" json:"flightreports,omitempty"`
	// contains filtered or unexported fields
}

func (*ListFlightreportsResponses) Descriptor deprecated 

func (*ListFlightreportsResponses) Descriptor() ([]byte, []int)

Deprecated: Use ListFlightreportsResponses.ProtoReflect.Descriptor instead.

func (*ListFlightreportsResponses) GetFlightreports 

func (x *ListFlightreportsResponses) GetFlightreports() []*Flightreport

func (*ListFlightreportsResponses) ProtoMessage 

func (*ListFlightreportsResponses) ProtoMessage()

func (*ListFlightreportsResponses) ProtoReflect 

func (x *ListFlightreportsResponses) ProtoReflect() protoreflect.Message

func (*ListFlightreportsResponses) Reset 

func (x *ListFlightreportsResponses) Reset()

func (*ListFlightreportsResponses) String 

func (x *ListFlightreportsResponses) String() string

type ListMissionsResponses 

type ListMissionsResponses struct {
	Missions []*Mission `protobuf:"bytes,1,rep,name=missions,proto3" json:"missions,omitempty"`
	// contains filtered or unexported fields
}

func (*ListMissionsResponses) Descriptor deprecated 

func (*ListMissionsResponses) Descriptor() ([]byte, []int)

Deprecated: Use ListMissionsResponses.ProtoReflect.Descriptor instead.

func (*ListMissionsResponses) GetMissions 

func (x *ListMissionsResponses) GetMissions() []*Mission

func (*ListMissionsResponses) ProtoMessage 

func (*ListMissionsResponses) ProtoMessage()

func (*ListMissionsResponses) ProtoReflect 

func (x *ListMissionsResponses) ProtoReflect() protoreflect.Message

func (*ListMissionsResponses) Reset 

func (x *ListMissionsResponses) Reset()

func (*ListMissionsResponses) String 

func (x *ListMissionsResponses) String() string

type ListVehiclesResponses 

type ListVehiclesResponses struct {
	Vehicles []*Vehicle `protobuf:"bytes,1,rep,name=vehicles,proto3" json:"vehicles,omitempty"`
	// contains filtered or unexported fields
}

func (*ListVehiclesResponses) Descriptor deprecated 

func (*ListVehiclesResponses) Descriptor() ([]byte, []int)

Deprecated: Use ListVehiclesResponses.ProtoReflect.Descriptor instead.

func (*ListVehiclesResponses) GetVehicles 

func (x *ListVehiclesResponses) GetVehicles() []*Vehicle

func (*ListVehiclesResponses) ProtoMessage 

func (*ListVehiclesResponses) ProtoMessage()

func (*ListVehiclesResponses) ProtoReflect 

func (x *ListVehiclesResponses) ProtoReflect() protoreflect.Message

func (*ListVehiclesResponses) Reset 

func (x *ListVehiclesResponses) Reset()

func (*ListVehiclesResponses) String 

func (x *ListVehiclesResponses) String() string

type ManageFlightplanServiceClient 

type ManageFlightplanServiceClient interface {
	ListFlightplans(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ListFlightplansResponses, error)
	GetFlightplan(ctx context.Context, in *GetFlightplanRequest, opts ...grpc.CallOption) (*Flightplan, error)
	CreateFlightplan(ctx context.Context, in *Flightplan, opts ...grpc.CallOption) (*Flightplan, error)
	UpdateFlightplan(ctx context.Context, in *Flightplan, opts ...grpc.CallOption) (*Flightplan, error)
	DeleteFlightplan(ctx context.Context, in *DeleteFlightplanRequest, opts ...grpc.CallOption) (*Empty, error)
}

ManageFlightplanServiceClient is the client API for ManageFlightplanService 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.

func NewManageFlightplanServiceClient 

func NewManageFlightplanServiceClient(cc grpc.ClientConnInterface) ManageFlightplanServiceClient

type ManageFlightplanServiceServer 

type ManageFlightplanServiceServer interface {
	ListFlightplans(context.Context, *Empty) (*ListFlightplansResponses, error)
	GetFlightplan(context.Context, *GetFlightplanRequest) (*Flightplan, error)
	CreateFlightplan(context.Context, *Flightplan) (*Flightplan, error)
	UpdateFlightplan(context.Context, *Flightplan) (*Flightplan, error)
	DeleteFlightplan(context.Context, *DeleteFlightplanRequest) (*Empty, error)
	// contains filtered or unexported methods
}

ManageFlightplanServiceServer is the server API for ManageFlightplanService service. All implementations must embed UnimplementedManageFlightplanServiceServer for forward compatibility

type ManageMissionServiceClient 

type ManageMissionServiceClient interface {
	ListMissions(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ListMissionsResponses, error)
	GetMission(ctx context.Context, in *GetMissionRequest, opts ...grpc.CallOption) (*Mission, error)
	CreateMission(ctx context.Context, in *Mission, opts ...grpc.CallOption) (*Mission, error)
	UpdateMission(ctx context.Context, in *Mission, opts ...grpc.CallOption) (*Mission, error)
	DeleteMission(ctx context.Context, in *DeleteMissionRequest, opts ...grpc.CallOption) (*Empty, error)
}

ManageMissionServiceClient is the client API for ManageMissionService 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.

func NewManageMissionServiceClient 

func NewManageMissionServiceClient(cc grpc.ClientConnInterface) ManageMissionServiceClient

type ManageMissionServiceServer 

type ManageMissionServiceServer interface {
	ListMissions(context.Context, *Empty) (*ListMissionsResponses, error)
	GetMission(context.Context, *GetMissionRequest) (*Mission, error)
	CreateMission(context.Context, *Mission) (*Mission, error)
	UpdateMission(context.Context, *Mission) (*Mission, error)
	DeleteMission(context.Context, *DeleteMissionRequest) (*Empty, error)
	// contains filtered or unexported methods
}

ManageMissionServiceServer is the server API for ManageMissionService service. All implementations must embed UnimplementedManageMissionServiceServer for forward compatibility

type ManageVehicleServiceClient 

type ManageVehicleServiceClient interface {
	ListVehicles(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ListVehiclesResponses, error)
	GetVehicle(ctx context.Context, in *GetVehicleRequest, opts ...grpc.CallOption) (*Vehicle, error)
	CreateVehicle(ctx context.Context, in *Vehicle, opts ...grpc.CallOption) (*Vehicle, error)
	UpdateVehicle(ctx context.Context, in *Vehicle, opts ...grpc.CallOption) (*Vehicle, error)
	DeleteVehicle(ctx context.Context, in *DeleteVehicleRequest, opts ...grpc.CallOption) (*Empty, error)
}

ManageVehicleServiceClient is the client API for ManageVehicleService 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.

func NewManageVehicleServiceClient 

func NewManageVehicleServiceClient(cc grpc.ClientConnInterface) ManageVehicleServiceClient

type ManageVehicleServiceServer 

type ManageVehicleServiceServer interface {
	ListVehicles(context.Context, *Empty) (*ListVehiclesResponses, error)
	GetVehicle(context.Context, *GetVehicleRequest) (*Vehicle, error)
	CreateVehicle(context.Context, *Vehicle) (*Vehicle, error)
	UpdateVehicle(context.Context, *Vehicle) (*Vehicle, error)
	DeleteVehicle(context.Context, *DeleteVehicleRequest) (*Empty, error)
	// contains filtered or unexported methods
}

ManageVehicleServiceServer is the server API for ManageVehicleService service. All implementations must embed UnimplementedManageVehicleServiceServer for forward compatibility

type Mission 

type Mission struct {
	Id         string      `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name       string      `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Navigation *Navigation `protobuf:"bytes,3,opt,name=navigation,proto3" json:"navigation,omitempty"`
	// contains filtered or unexported fields
}

func (*Mission) Descriptor deprecated 

func (*Mission) Descriptor() ([]byte, []int)

Deprecated: Use Mission.ProtoReflect.Descriptor instead.

func (*Mission) GetId 

func (x *Mission) GetId() string

func (*Mission) GetName 

func (x *Mission) GetName() string

func (*Mission) GetNavigation 

func (x *Mission) GetNavigation() *Navigation

func (*Mission) ProtoMessage 

func (*Mission) ProtoMessage()

func (*Mission) ProtoReflect 

func (x *Mission) ProtoReflect() protoreflect.Message

func (*Mission) Reset 

func (x *Mission) Reset()

func (*Mission) String 

func (x *Mission) String() string

type MissionCopiedEvent 

type MissionCopiedEvent struct {
	FleetId           string `protobuf:"bytes,1,opt,name=fleet_id,json=fleetId,proto3" json:"fleet_id,omitempty"`
	OriginalMissionId string `protobuf:"bytes,2,opt,name=original_mission_id,json=originalMissionId,proto3" json:"original_mission_id,omitempty"`
	NewMissionId      string `protobuf:"bytes,3,opt,name=new_mission_id,json=newMissionId,proto3" json:"new_mission_id,omitempty"`
	// contains filtered or unexported fields
}

func (*MissionCopiedEvent) Descriptor deprecated 

func (*MissionCopiedEvent) Descriptor() ([]byte, []int)

Deprecated: Use MissionCopiedEvent.ProtoReflect.Descriptor instead.

func (*MissionCopiedEvent) GetFleetId 

func (x *MissionCopiedEvent) GetFleetId() string

func (*MissionCopiedEvent) GetNewMissionId 

func (x *MissionCopiedEvent) GetNewMissionId() string

func (*MissionCopiedEvent) GetOriginalMissionId 

func (x *MissionCopiedEvent) GetOriginalMissionId() string

func (*MissionCopiedEvent) ProtoMessage 

func (*MissionCopiedEvent) ProtoMessage()

func (*MissionCopiedEvent) ProtoReflect 

func (x *MissionCopiedEvent) ProtoReflect() protoreflect.Message

func (*MissionCopiedEvent) Reset 

func (x *MissionCopiedEvent) Reset()

func (*MissionCopiedEvent) String 

func (x *MissionCopiedEvent) String() string
type Navigation struct {
	UploadId                 string      `protobuf:"bytes,1,opt,name=upload_id,json=uploadId,proto3" json:"upload_id,omitempty"`
	TakeoffPointGroundHeight float64     `` /* 139-byte string literal not displayed */
	Waypoints                []*Waypoint `protobuf:"bytes,3,rep,name=waypoints,proto3" json:"waypoints,omitempty"`
	// contains filtered or unexported fields
}
func (*Navigation) Descriptor() ([]byte, []int)

Deprecated: Use Navigation.ProtoReflect.Descriptor instead. 

func (x *Navigation) GetTakeoffPointGroundHeight() float64
func (x *Navigation) GetUploadId() string
func (x *Navigation) GetWaypoints() []*Waypoint
func (*Navigation) ProtoMessage()
func (x *Navigation) ProtoReflect() protoreflect.Message
func (x *Navigation) Reset()
func (x *Navigation) String() string

type OperateFlightServiceClient 

type OperateFlightServiceClient interface {
	ListFlightoperations(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ListFlightoperationsResponses, error)
	GetFlightoperation(ctx context.Context, in *GetFlightoperationRequest, opts ...grpc.CallOption) (*Flightoperation, error)
	CompleteFlightoperation(ctx context.Context, in *CompleteFlightoperationRequest, opts ...grpc.CallOption) (*Empty, error)
}

OperateFlightServiceClient is the client API for OperateFlightService 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.

func NewOperateFlightServiceClient 

func NewOperateFlightServiceClient(cc grpc.ClientConnInterface) OperateFlightServiceClient

type OperateFlightServiceServer 

type OperateFlightServiceServer interface {
	ListFlightoperations(context.Context, *Empty) (*ListFlightoperationsResponses, error)
	GetFlightoperation(context.Context, *GetFlightoperationRequest) (*Flightoperation, error)
	CompleteFlightoperation(context.Context, *CompleteFlightoperationRequest) (*Empty, error)
	// contains filtered or unexported methods
}

OperateFlightServiceServer is the server API for OperateFlightService service. All implementations must embed UnimplementedOperateFlightServiceServer for forward compatibility

type PullCommandRequest 

type PullCommandRequest struct {
	Id        string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	CommandId string `protobuf:"bytes,2,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// contains filtered or unexported fields
}

func (*PullCommandRequest) Descriptor deprecated 

func (*PullCommandRequest) Descriptor() ([]byte, []int)

Deprecated: Use PullCommandRequest.ProtoReflect.Descriptor instead.

func (*PullCommandRequest) GetCommandId 

func (x *PullCommandRequest) GetCommandId() string

func (*PullCommandRequest) GetId 

func (x *PullCommandRequest) GetId() string

func (*PullCommandRequest) ProtoMessage 

func (*PullCommandRequest) ProtoMessage()

func (*PullCommandRequest) ProtoReflect 

func (x *PullCommandRequest) ProtoReflect() protoreflect.Message

func (*PullCommandRequest) Reset 

func (x *PullCommandRequest) Reset()

func (*PullCommandRequest) String 

func (x *PullCommandRequest) String() string

type PullCommandResponse 

type PullCommandResponse struct {
	Id        string      `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	CommandId string      `protobuf:"bytes,2,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	Type      CommandType `protobuf:"varint,3,opt,name=type,proto3,enum=skysign_proto.CommandType" json:"type,omitempty"`
	// contains filtered or unexported fields
}

func (*PullCommandResponse) Descriptor deprecated 

func (*PullCommandResponse) Descriptor() ([]byte, []int)

Deprecated: Use PullCommandResponse.ProtoReflect.Descriptor instead.

func (*PullCommandResponse) GetCommandId 

func (x *PullCommandResponse) GetCommandId() string

func (*PullCommandResponse) GetId 

func (x *PullCommandResponse) GetId() string

func (*PullCommandResponse) GetType 

func (x *PullCommandResponse) GetType() CommandType

func (*PullCommandResponse) ProtoMessage 

func (*PullCommandResponse) ProtoMessage()

func (*PullCommandResponse) ProtoReflect 

func (x *PullCommandResponse) ProtoReflect() protoreflect.Message

func (*PullCommandResponse) Reset 

func (x *PullCommandResponse) Reset()

func (*PullCommandResponse) String 

func (x *PullCommandResponse) String() string

type PullTelemetryRequest 

type PullTelemetryRequest struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (*PullTelemetryRequest) Descriptor deprecated 

func (*PullTelemetryRequest) Descriptor() ([]byte, []int)

Deprecated: Use PullTelemetryRequest.ProtoReflect.Descriptor instead.

func (*PullTelemetryRequest) GetId 

func (x *PullTelemetryRequest) GetId() string

func (*PullTelemetryRequest) ProtoMessage 

func (*PullTelemetryRequest) ProtoMessage()

func (*PullTelemetryRequest) ProtoReflect 

func (x *PullTelemetryRequest) ProtoReflect() protoreflect.Message

func (*PullTelemetryRequest) Reset 

func (x *PullTelemetryRequest) Reset()

func (*PullTelemetryRequest) String 

func (x *PullTelemetryRequest) String() string

type PullTelemetryResponse 

type PullTelemetryResponse struct {
	Id        string     `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Telemetry *Telemetry `protobuf:"bytes,2,opt,name=telemetry,proto3" json:"telemetry,omitempty"`
	// contains filtered or unexported fields
}

func (*PullTelemetryResponse) Descriptor deprecated 

func (*PullTelemetryResponse) Descriptor() ([]byte, []int)

Deprecated: Use PullTelemetryResponse.ProtoReflect.Descriptor instead.

func (*PullTelemetryResponse) GetId 

func (x *PullTelemetryResponse) GetId() string

func (*PullTelemetryResponse) GetTelemetry 

func (x *PullTelemetryResponse) GetTelemetry() *Telemetry

func (*PullTelemetryResponse) ProtoMessage 

func (*PullTelemetryResponse) ProtoMessage()

func (*PullTelemetryResponse) ProtoReflect 

func (x *PullTelemetryResponse) ProtoReflect() protoreflect.Message

func (*PullTelemetryResponse) Reset 

func (x *PullTelemetryResponse) Reset()

func (*PullTelemetryResponse) String 

func (x *PullTelemetryResponse) String() string

type PullUploadMissionRequest 

type PullUploadMissionRequest struct {
	Id        string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	CommandId string `protobuf:"bytes,2,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// contains filtered or unexported fields
}

func (*PullUploadMissionRequest) Descriptor deprecated 

func (*PullUploadMissionRequest) Descriptor() ([]byte, []int)

Deprecated: Use PullUploadMissionRequest.ProtoReflect.Descriptor instead.

func (*PullUploadMissionRequest) GetCommandId 

func (x *PullUploadMissionRequest) GetCommandId() string

func (*PullUploadMissionRequest) GetId 

func (x *PullUploadMissionRequest) GetId() string

func (*PullUploadMissionRequest) ProtoMessage 

func (*PullUploadMissionRequest) ProtoMessage()

func (*PullUploadMissionRequest) ProtoReflect 

func (x *PullUploadMissionRequest) ProtoReflect() protoreflect.Message

func (*PullUploadMissionRequest) Reset 

func (x *PullUploadMissionRequest) Reset()

func (*PullUploadMissionRequest) String 

func (x *PullUploadMissionRequest) String() string

type PullUploadMissionResponse 

type PullUploadMissionResponse struct {
	Id        string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	CommandId string `protobuf:"bytes,2,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	MissionId string `protobuf:"bytes,3,opt,name=mission_id,json=missionId,proto3" json:"mission_id,omitempty"`
	// contains filtered or unexported fields
}

func (*PullUploadMissionResponse) Descriptor deprecated 

func (*PullUploadMissionResponse) Descriptor() ([]byte, []int)

Deprecated: Use PullUploadMissionResponse.ProtoReflect.Descriptor instead.

func (*PullUploadMissionResponse) GetCommandId 

func (x *PullUploadMissionResponse) GetCommandId() string

func (*PullUploadMissionResponse) GetId 

func (x *PullUploadMissionResponse) GetId() string

func (*PullUploadMissionResponse) GetMissionId 

func (x *PullUploadMissionResponse) GetMissionId() string

func (*PullUploadMissionResponse) ProtoMessage 

func (*PullUploadMissionResponse) ProtoMessage()

func (*PullUploadMissionResponse) ProtoReflect 

func (x *PullUploadMissionResponse) ProtoReflect() protoreflect.Message

func (*PullUploadMissionResponse) Reset 

func (x *PullUploadMissionResponse) Reset()

func (*PullUploadMissionResponse) String 

func (x *PullUploadMissionResponse) String() string

type PushCommandRequest 

type PushCommandRequest struct {
	Id   string      `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Type CommandType `protobuf:"varint,2,opt,name=type,proto3,enum=skysign_proto.CommandType" json:"type,omitempty"`
	// contains filtered or unexported fields
}

func (*PushCommandRequest) Descriptor deprecated 

func (*PushCommandRequest) Descriptor() ([]byte, []int)

Deprecated: Use PushCommandRequest.ProtoReflect.Descriptor instead.

func (*PushCommandRequest) GetId 

func (x *PushCommandRequest) GetId() string

func (*PushCommandRequest) GetType 

func (x *PushCommandRequest) GetType() CommandType

func (*PushCommandRequest) ProtoMessage 

func (*PushCommandRequest) ProtoMessage()

func (*PushCommandRequest) ProtoReflect 

func (x *PushCommandRequest) ProtoReflect() protoreflect.Message

func (*PushCommandRequest) Reset 

func (x *PushCommandRequest) Reset()

func (*PushCommandRequest) String 

func (x *PushCommandRequest) String() string

type PushCommandResponse 

type PushCommandResponse struct {
	Id        string      `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Type      CommandType `protobuf:"varint,2,opt,name=type,proto3,enum=skysign_proto.CommandType" json:"type,omitempty"`
	CommandId string      `protobuf:"bytes,3,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// contains filtered or unexported fields
}

func (*PushCommandResponse) Descriptor deprecated 

func (*PushCommandResponse) Descriptor() ([]byte, []int)

Deprecated: Use PushCommandResponse.ProtoReflect.Descriptor instead.

func (*PushCommandResponse) GetCommandId 

func (x *PushCommandResponse) GetCommandId() string

func (*PushCommandResponse) GetId 

func (x *PushCommandResponse) GetId() string

func (*PushCommandResponse) GetType 

func (x *PushCommandResponse) GetType() CommandType

func (*PushCommandResponse) ProtoMessage 

func (*PushCommandResponse) ProtoMessage()

func (*PushCommandResponse) ProtoReflect 

func (x *PushCommandResponse) ProtoReflect() protoreflect.Message

func (*PushCommandResponse) Reset 

func (x *PushCommandResponse) Reset()

func (*PushCommandResponse) String 

func (x *PushCommandResponse) String() string

type PushTelemetryRequest 

type PushTelemetryRequest struct {
	Id        string     `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Telemetry *Telemetry `protobuf:"bytes,2,opt,name=telemetry,proto3" json:"telemetry,omitempty"`
	// contains filtered or unexported fields
}

func (*PushTelemetryRequest) Descriptor deprecated 

func (*PushTelemetryRequest) Descriptor() ([]byte, []int)

Deprecated: Use PushTelemetryRequest.ProtoReflect.Descriptor instead.

func (*PushTelemetryRequest) GetId 

func (x *PushTelemetryRequest) GetId() string

func (*PushTelemetryRequest) GetTelemetry 

func (x *PushTelemetryRequest) GetTelemetry() *Telemetry

func (*PushTelemetryRequest) ProtoMessage 

func (*PushTelemetryRequest) ProtoMessage()

func (*PushTelemetryRequest) ProtoReflect 

func (x *PushTelemetryRequest) ProtoReflect() protoreflect.Message

func (*PushTelemetryRequest) Reset 

func (x *PushTelemetryRequest) Reset()

func (*PushTelemetryRequest) String 

func (x *PushTelemetryRequest) String() string

type PushTelemetryResponse 

type PushTelemetryResponse struct {
	Id         string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	CommandIds []string `protobuf:"bytes,2,rep,name=command_ids,json=commandIds,proto3" json:"command_ids,omitempty"`
	// contains filtered or unexported fields
}

func (*PushTelemetryResponse) Descriptor deprecated 

func (*PushTelemetryResponse) Descriptor() ([]byte, []int)

Deprecated: Use PushTelemetryResponse.ProtoReflect.Descriptor instead.

func (*PushTelemetryResponse) GetCommandIds 

func (x *PushTelemetryResponse) GetCommandIds() []string

func (*PushTelemetryResponse) GetId 

func (x *PushTelemetryResponse) GetId() string

func (*PushTelemetryResponse) ProtoMessage 

func (*PushTelemetryResponse) ProtoMessage()

func (*PushTelemetryResponse) ProtoReflect 

func (x *PushTelemetryResponse) ProtoReflect() protoreflect.Message

func (*PushTelemetryResponse) Reset 

func (x *PushTelemetryResponse) Reset()

func (*PushTelemetryResponse) String 

func (x *PushTelemetryResponse) String() string

type PushUploadMissionRequest 

type PushUploadMissionRequest struct {
	Id        string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	MissionId string `protobuf:"bytes,2,opt,name=mission_id,json=missionId,proto3" json:"mission_id,omitempty"`
	// contains filtered or unexported fields
}

func (*PushUploadMissionRequest) Descriptor deprecated 

func (*PushUploadMissionRequest) Descriptor() ([]byte, []int)

Deprecated: Use PushUploadMissionRequest.ProtoReflect.Descriptor instead.

func (*PushUploadMissionRequest) GetId 

func (x *PushUploadMissionRequest) GetId() string

func (*PushUploadMissionRequest) GetMissionId 

func (x *PushUploadMissionRequest) GetMissionId() string

func (*PushUploadMissionRequest) ProtoMessage 

func (*PushUploadMissionRequest) ProtoMessage()

func (*PushUploadMissionRequest) ProtoReflect 

func (x *PushUploadMissionRequest) ProtoReflect() protoreflect.Message

func (*PushUploadMissionRequest) Reset 

func (x *PushUploadMissionRequest) Reset()

func (*PushUploadMissionRequest) String 

func (x *PushUploadMissionRequest) String() string

type PushUploadMissionResponse 

type PushUploadMissionResponse struct {
	Id        string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	MissionId string `protobuf:"bytes,2,opt,name=mission_id,json=missionId,proto3" json:"mission_id,omitempty"`
	CommandId string `protobuf:"bytes,3,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// contains filtered or unexported fields
}

func (*PushUploadMissionResponse) Descriptor deprecated 

func (*PushUploadMissionResponse) Descriptor() ([]byte, []int)

Deprecated: Use PushUploadMissionResponse.ProtoReflect.Descriptor instead.

func (*PushUploadMissionResponse) GetCommandId 

func (x *PushUploadMissionResponse) GetCommandId() string

func (*PushUploadMissionResponse) GetId 

func (x *PushUploadMissionResponse) GetId() string

func (*PushUploadMissionResponse) GetMissionId 

func (x *PushUploadMissionResponse) GetMissionId() string

func (*PushUploadMissionResponse) ProtoMessage 

func (*PushUploadMissionResponse) ProtoMessage()

func (*PushUploadMissionResponse) ProtoReflect 

func (x *PushUploadMissionResponse) ProtoReflect() protoreflect.Message

func (*PushUploadMissionResponse) Reset 

func (x *PushUploadMissionResponse) Reset()

func (*PushUploadMissionResponse) String 

func (x *PushUploadMissionResponse) String() string

type ReportFlightServiceClient 

type ReportFlightServiceClient interface {
	ListFlightreports(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ListFlightreportsResponses, error)
	GetFlightreport(ctx context.Context, in *GetFlightreportRequest, opts ...grpc.CallOption) (*Flightreport, error)
}

ReportFlightServiceClient is the client API for ReportFlightService 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.

func NewReportFlightServiceClient 

func NewReportFlightServiceClient(cc grpc.ClientConnInterface) ReportFlightServiceClient

type ReportFlightServiceServer 

type ReportFlightServiceServer interface {
	ListFlightreports(context.Context, *Empty) (*ListFlightreportsResponses, error)
	GetFlightreport(context.Context, *GetFlightreportRequest) (*Flightreport, error)
	// contains filtered or unexported methods
}

ReportFlightServiceServer is the server API for ReportFlightService service. All implementations must embed UnimplementedReportFlightServiceServer for forward compatibility

type Telemetry 

type Telemetry struct {
	Latitude         float64 `protobuf:"fixed64,1,opt,name=latitude,proto3" json:"latitude,omitempty"`
	Longitude        float64 `protobuf:"fixed64,2,opt,name=longitude,proto3" json:"longitude,omitempty"`
	Altitude         float64 `protobuf:"fixed64,3,opt,name=altitude,proto3" json:"altitude,omitempty"`
	RelativeAltitude float64 `protobuf:"fixed64,4,opt,name=relative_altitude,json=relativeAltitude,proto3" json:"relative_altitude,omitempty"`
	Speed            float64 `protobuf:"fixed64,5,opt,name=speed,proto3" json:"speed,omitempty"`
	Armed            bool    `protobuf:"varint,6,opt,name=armed,proto3" json:"armed,omitempty"`
	FlightMode       string  `protobuf:"bytes,7,opt,name=flight_mode,json=flightMode,proto3" json:"flight_mode,omitempty"`
	OrientationX     float64 `protobuf:"fixed64,8,opt,name=orientation_x,json=orientationX,proto3" json:"orientation_x,omitempty"`
	OrientationY     float64 `protobuf:"fixed64,9,opt,name=orientation_y,json=orientationY,proto3" json:"orientation_y,omitempty"`
	OrientationZ     float64 `protobuf:"fixed64,10,opt,name=orientation_z,json=orientationZ,proto3" json:"orientation_z,omitempty"`
	OrientationW     float64 `protobuf:"fixed64,11,opt,name=orientation_w,json=orientationW,proto3" json:"orientation_w,omitempty"`
	// contains filtered or unexported fields
}

func (*Telemetry) Descriptor deprecated 

func (*Telemetry) Descriptor() ([]byte, []int)

Deprecated: Use Telemetry.ProtoReflect.Descriptor instead.

func (*Telemetry) GetAltitude 

func (x *Telemetry) GetAltitude() float64

func (*Telemetry) GetArmed 

func (x *Telemetry) GetArmed() bool

func (*Telemetry) GetFlightMode 

func (x *Telemetry) GetFlightMode() string

func (*Telemetry) GetLatitude 

func (x *Telemetry) GetLatitude() float64

func (*Telemetry) GetLongitude 

func (x *Telemetry) GetLongitude() float64

func (*Telemetry) GetOrientationW 

func (x *Telemetry) GetOrientationW() float64

func (*Telemetry) GetOrientationX 

func (x *Telemetry) GetOrientationX() float64

func (*Telemetry) GetOrientationY 

func (x *Telemetry) GetOrientationY() float64

func (*Telemetry) GetOrientationZ 

func (x *Telemetry) GetOrientationZ() float64

func (*Telemetry) GetRelativeAltitude 

func (x *Telemetry) GetRelativeAltitude() float64

func (*Telemetry) GetSpeed 

func (x *Telemetry) GetSpeed() float64

func (*Telemetry) ProtoMessage 

func (*Telemetry) ProtoMessage()

func (*Telemetry) ProtoReflect 

func (x *Telemetry) ProtoReflect() protoreflect.Message

func (*Telemetry) Reset 

func (x *Telemetry) Reset()

func (*Telemetry) String 

func (x *Telemetry) String() string

type TelemetryUpdatedEvent 

type TelemetryUpdatedEvent struct {
	CommunicationId string     `protobuf:"bytes,1,opt,name=communication_id,json=communicationId,proto3" json:"communication_id,omitempty"`
	Telemetry       *Telemetry `protobuf:"bytes,2,opt,name=telemetry,proto3" json:"telemetry,omitempty"`
	// contains filtered or unexported fields
}

func (*TelemetryUpdatedEvent) Descriptor deprecated 

func (*TelemetryUpdatedEvent) Descriptor() ([]byte, []int)

Deprecated: Use TelemetryUpdatedEvent.ProtoReflect.Descriptor instead.

func (*TelemetryUpdatedEvent) GetCommunicationId 

func (x *TelemetryUpdatedEvent) GetCommunicationId() string

func (*TelemetryUpdatedEvent) GetTelemetry 

func (x *TelemetryUpdatedEvent) GetTelemetry() *Telemetry

func (*TelemetryUpdatedEvent) ProtoMessage 

func (*TelemetryUpdatedEvent) ProtoMessage()

func (*TelemetryUpdatedEvent) ProtoReflect 

func (x *TelemetryUpdatedEvent) ProtoReflect() protoreflect.Message

func (*TelemetryUpdatedEvent) Reset 

func (x *TelemetryUpdatedEvent) Reset()

func (*TelemetryUpdatedEvent) String 

func (x *TelemetryUpdatedEvent) String() string

type UnimplementedActionServiceServer 

type UnimplementedActionServiceServer struct {
}

UnimplementedActionServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedActionServiceServer) GetTrajectory 

func (UnimplementedActionServiceServer) GetTrajectory(context.Context, *GetTrajectoryRequest) (*GetTrajectoryResponse, error)

type UnimplementedAssignAssetsToFleetServiceServer 

type UnimplementedAssignAssetsToFleetServiceServer struct {
}

UnimplementedAssignAssetsToFleetServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedAssignAssetsToFleetServiceServer) GetAssignments 

func (UnimplementedAssignAssetsToFleetServiceServer) GetAssignments(context.Context, *GetAssignmentsRequest) (*GetAssignmentsResponse, error)

func (UnimplementedAssignAssetsToFleetServiceServer) UpdateAssignments 

func (UnimplementedAssignAssetsToFleetServiceServer) UpdateAssignments(context.Context, *UpdateAssignmentsRequest) (*UpdateAssignmentsResponse, error)

type UnimplementedChangeFlightplanServiceServer 

type UnimplementedChangeFlightplanServiceServer struct {
}

UnimplementedChangeFlightplanServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedChangeFlightplanServiceServer) ChangeNumberOfVehicles 

func (UnimplementedChangeFlightplanServiceServer) ChangeNumberOfVehicles(context.Context, *ChangeNumberOfVehiclesRequest) (*ChangeNumberOfVehiclesResponse, error)

type UnimplementedCommunicationEdgeServiceServer 

type UnimplementedCommunicationEdgeServiceServer struct {
}

UnimplementedCommunicationEdgeServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedCommunicationEdgeServiceServer) PullCommand 

func (UnimplementedCommunicationEdgeServiceServer) PullCommand(context.Context, *PullCommandRequest) (*PullCommandResponse, error)

func (UnimplementedCommunicationEdgeServiceServer) PullUploadMission 

func (UnimplementedCommunicationEdgeServiceServer) PullUploadMission(context.Context, *PullUploadMissionRequest) (*PullUploadMissionResponse, error)

func (UnimplementedCommunicationEdgeServiceServer) PushTelemetry 

func (UnimplementedCommunicationEdgeServiceServer) PushTelemetry(context.Context, *PushTelemetryRequest) (*PushTelemetryResponse, error)

type UnimplementedCommunicationUserServiceServer 

type UnimplementedCommunicationUserServiceServer struct {
}

UnimplementedCommunicationUserServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedCommunicationUserServiceServer) PullTelemetry 

func (UnimplementedCommunicationUserServiceServer) PullTelemetry(context.Context, *PullTelemetryRequest) (*PullTelemetryResponse, error)

func (UnimplementedCommunicationUserServiceServer) PushCommand 

func (UnimplementedCommunicationUserServiceServer) PushCommand(context.Context, *PushCommandRequest) (*PushCommandResponse, error)

func (UnimplementedCommunicationUserServiceServer) PushUploadMission 

func (UnimplementedCommunicationUserServiceServer) PushUploadMission(context.Context, *PushUploadMissionRequest) (*PushUploadMissionResponse, error)

type UnimplementedExecuteFlightplanServiceServer 

type UnimplementedExecuteFlightplanServiceServer struct {
}

UnimplementedExecuteFlightplanServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedExecuteFlightplanServiceServer) ExecuteFlightplan 

func (UnimplementedExecuteFlightplanServiceServer) ExecuteFlightplan(context.Context, *ExecuteFlightplanRequest) (*ExecuteFlightplanResponse, error)

type UnimplementedHelperUserServiceServer 

type UnimplementedHelperUserServiceServer struct {
}

UnimplementedHelperUserServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedHelperUserServiceServer) GetEllipsoidHeight 

func (UnimplementedHelperUserServiceServer) GetEllipsoidHeight(context.Context, *GetEllipsoidHeightRequest) (*GetEllipsoidHeightResponse, error)

type UnimplementedManageFlightplanServiceServer 

type UnimplementedManageFlightplanServiceServer struct {
}

UnimplementedManageFlightplanServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedManageFlightplanServiceServer) CreateFlightplan 

func (UnimplementedManageFlightplanServiceServer) CreateFlightplan(context.Context, *Flightplan) (*Flightplan, error)

func (UnimplementedManageFlightplanServiceServer) DeleteFlightplan 

func (UnimplementedManageFlightplanServiceServer) DeleteFlightplan(context.Context, *DeleteFlightplanRequest) (*Empty, error)

func (UnimplementedManageFlightplanServiceServer) GetFlightplan 

func (UnimplementedManageFlightplanServiceServer) GetFlightplan(context.Context, *GetFlightplanRequest) (*Flightplan, error)

func (UnimplementedManageFlightplanServiceServer) ListFlightplans 

func (UnimplementedManageFlightplanServiceServer) ListFlightplans(context.Context, *Empty) (*ListFlightplansResponses, error)

func (UnimplementedManageFlightplanServiceServer) UpdateFlightplan 

func (UnimplementedManageFlightplanServiceServer) UpdateFlightplan(context.Context, *Flightplan) (*Flightplan, error)

type UnimplementedManageMissionServiceServer 

type UnimplementedManageMissionServiceServer struct {
}

UnimplementedManageMissionServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedManageMissionServiceServer) CreateMission 

func (UnimplementedManageMissionServiceServer) CreateMission(context.Context, *Mission) (*Mission, error)

func (UnimplementedManageMissionServiceServer) DeleteMission 

func (UnimplementedManageMissionServiceServer) DeleteMission(context.Context, *DeleteMissionRequest) (*Empty, error)

func (UnimplementedManageMissionServiceServer) GetMission 

func (UnimplementedManageMissionServiceServer) GetMission(context.Context, *GetMissionRequest) (*Mission, error)

func (UnimplementedManageMissionServiceServer) ListMissions 

func (UnimplementedManageMissionServiceServer) ListMissions(context.Context, *Empty) (*ListMissionsResponses, error)

func (UnimplementedManageMissionServiceServer) UpdateMission 

func (UnimplementedManageMissionServiceServer) UpdateMission(context.Context, *Mission) (*Mission, error)

type UnimplementedManageVehicleServiceServer 

type UnimplementedManageVehicleServiceServer struct {
}

UnimplementedManageVehicleServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedManageVehicleServiceServer) CreateVehicle 

func (UnimplementedManageVehicleServiceServer) CreateVehicle(context.Context, *Vehicle) (*Vehicle, error)

func (UnimplementedManageVehicleServiceServer) DeleteVehicle 

func (UnimplementedManageVehicleServiceServer) DeleteVehicle(context.Context, *DeleteVehicleRequest) (*Empty, error)

func (UnimplementedManageVehicleServiceServer) GetVehicle 

func (UnimplementedManageVehicleServiceServer) GetVehicle(context.Context, *GetVehicleRequest) (*Vehicle, error)

func (UnimplementedManageVehicleServiceServer) ListVehicles 

func (UnimplementedManageVehicleServiceServer) ListVehicles(context.Context, *Empty) (*ListVehiclesResponses, error)

func (UnimplementedManageVehicleServiceServer) UpdateVehicle 

func (UnimplementedManageVehicleServiceServer) UpdateVehicle(context.Context, *Vehicle) (*Vehicle, error)

type UnimplementedOperateFlightServiceServer 

type UnimplementedOperateFlightServiceServer struct {
}

UnimplementedOperateFlightServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedOperateFlightServiceServer) CompleteFlightoperation 

func (UnimplementedOperateFlightServiceServer) CompleteFlightoperation(context.Context, *CompleteFlightoperationRequest) (*Empty, error)

func (UnimplementedOperateFlightServiceServer) GetFlightoperation 

func (UnimplementedOperateFlightServiceServer) GetFlightoperation(context.Context, *GetFlightoperationRequest) (*Flightoperation, error)

func (UnimplementedOperateFlightServiceServer) ListFlightoperations 

func (UnimplementedOperateFlightServiceServer) ListFlightoperations(context.Context, *Empty) (*ListFlightoperationsResponses, error)

type UnimplementedReportFlightServiceServer 

type UnimplementedReportFlightServiceServer struct {
}

UnimplementedReportFlightServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedReportFlightServiceServer) GetFlightreport 

func (UnimplementedReportFlightServiceServer) GetFlightreport(context.Context, *GetFlightreportRequest) (*Flightreport, error)

func (UnimplementedReportFlightServiceServer) ListFlightreports 

func (UnimplementedReportFlightServiceServer) ListFlightreports(context.Context, *Empty) (*ListFlightreportsResponses, error)

type UnimplementedUploadMissionEdgeServiceServer 

type UnimplementedUploadMissionEdgeServiceServer struct {
}

UnimplementedUploadMissionEdgeServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedUploadMissionEdgeServiceServer) GetUploadMission 

func (UnimplementedUploadMissionEdgeServiceServer) GetUploadMission(context.Context, *GetUploadMissionRequest) (*UploadMission, error)

type UnsafeActionServiceServer 

type UnsafeActionServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeActionServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ActionServiceServer will result in compilation errors.

type UnsafeAssignAssetsToFleetServiceServer 

type UnsafeAssignAssetsToFleetServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeAssignAssetsToFleetServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to AssignAssetsToFleetServiceServer will result in compilation errors.

type UnsafeChangeFlightplanServiceServer 

type UnsafeChangeFlightplanServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeChangeFlightplanServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ChangeFlightplanServiceServer will result in compilation errors.

type UnsafeCommunicationEdgeServiceServer 

type UnsafeCommunicationEdgeServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeCommunicationEdgeServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to CommunicationEdgeServiceServer will result in compilation errors.

type UnsafeCommunicationUserServiceServer 

type UnsafeCommunicationUserServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeCommunicationUserServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to CommunicationUserServiceServer will result in compilation errors.

type UnsafeExecuteFlightplanServiceServer 

type UnsafeExecuteFlightplanServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeExecuteFlightplanServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ExecuteFlightplanServiceServer will result in compilation errors.

type UnsafeHelperUserServiceServer 

type UnsafeHelperUserServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeHelperUserServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to HelperUserServiceServer will result in compilation errors.

type UnsafeManageFlightplanServiceServer 

type UnsafeManageFlightplanServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeManageFlightplanServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ManageFlightplanServiceServer will result in compilation errors.

type UnsafeManageMissionServiceServer 

type UnsafeManageMissionServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeManageMissionServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ManageMissionServiceServer will result in compilation errors.

type UnsafeManageVehicleServiceServer 

type UnsafeManageVehicleServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeManageVehicleServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ManageVehicleServiceServer will result in compilation errors.

type UnsafeOperateFlightServiceServer 

type UnsafeOperateFlightServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeOperateFlightServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to OperateFlightServiceServer will result in compilation errors.

type UnsafeReportFlightServiceServer 

type UnsafeReportFlightServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeReportFlightServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ReportFlightServiceServer will result in compilation errors.

type UnsafeUploadMissionEdgeServiceServer 

type UnsafeUploadMissionEdgeServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeUploadMissionEdgeServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to UploadMissionEdgeServiceServer will result in compilation errors.

type UpdateAssignmentsRequest 

type UpdateAssignmentsRequest struct {
	Id          string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Assignments []*Assignment `protobuf:"bytes,2,rep,name=assignments,proto3" json:"assignments,omitempty"`
	// contains filtered or unexported fields
}

func (*UpdateAssignmentsRequest) Descriptor deprecated 

func (*UpdateAssignmentsRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpdateAssignmentsRequest.ProtoReflect.Descriptor instead.

func (*UpdateAssignmentsRequest) GetAssignments 

func (x *UpdateAssignmentsRequest) GetAssignments() []*Assignment

func (*UpdateAssignmentsRequest) GetId 

func (x *UpdateAssignmentsRequest) GetId() string

func (*UpdateAssignmentsRequest) ProtoMessage 

func (*UpdateAssignmentsRequest) ProtoMessage()

func (*UpdateAssignmentsRequest) ProtoReflect 

func (x *UpdateAssignmentsRequest) ProtoReflect() protoreflect.Message

func (*UpdateAssignmentsRequest) Reset 

func (x *UpdateAssignmentsRequest) Reset()

func (*UpdateAssignmentsRequest) String 

func (x *UpdateAssignmentsRequest) String() string

type UpdateAssignmentsResponse 

type UpdateAssignmentsResponse struct {
	Id          string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Assignments []*Assignment `protobuf:"bytes,2,rep,name=assignments,proto3" json:"assignments,omitempty"`
	// contains filtered or unexported fields
}

func (*UpdateAssignmentsResponse) Descriptor deprecated 

func (*UpdateAssignmentsResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpdateAssignmentsResponse.ProtoReflect.Descriptor instead.

func (*UpdateAssignmentsResponse) GetAssignments 

func (x *UpdateAssignmentsResponse) GetAssignments() []*Assignment

func (*UpdateAssignmentsResponse) GetId 

func (x *UpdateAssignmentsResponse) GetId() string

func (*UpdateAssignmentsResponse) ProtoMessage 

func (*UpdateAssignmentsResponse) ProtoMessage()

func (*UpdateAssignmentsResponse) ProtoReflect 

func (x *UpdateAssignmentsResponse) ProtoReflect() protoreflect.Message

func (*UpdateAssignmentsResponse) Reset 

func (x *UpdateAssignmentsResponse) Reset()

func (*UpdateAssignmentsResponse) String 

func (x *UpdateAssignmentsResponse) String() string

type UploadMission 

type UploadMission struct {
	Id        string      `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Waypoints []*Waypoint `protobuf:"bytes,2,rep,name=waypoints,proto3" json:"waypoints,omitempty"`
	// contains filtered or unexported fields
}

func (*UploadMission) Descriptor deprecated 

func (*UploadMission) Descriptor() ([]byte, []int)

Deprecated: Use UploadMission.ProtoReflect.Descriptor instead.

func (*UploadMission) GetId 

func (x *UploadMission) GetId() string

func (*UploadMission) GetWaypoints 

func (x *UploadMission) GetWaypoints() []*Waypoint

func (*UploadMission) ProtoMessage 

func (*UploadMission) ProtoMessage()

func (*UploadMission) ProtoReflect 

func (x *UploadMission) ProtoReflect() protoreflect.Message

func (*UploadMission) Reset 

func (x *UploadMission) Reset()

func (*UploadMission) String 

func (x *UploadMission) String() string

type UploadMissionEdgeServiceClient 

type UploadMissionEdgeServiceClient interface {
	GetUploadMission(ctx context.Context, in *GetUploadMissionRequest, opts ...grpc.CallOption) (*UploadMission, error)
}

UploadMissionEdgeServiceClient is the client API for UploadMissionEdgeService 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.

func NewUploadMissionEdgeServiceClient 

func NewUploadMissionEdgeServiceClient(cc grpc.ClientConnInterface) UploadMissionEdgeServiceClient

type UploadMissionEdgeServiceServer 

type UploadMissionEdgeServiceServer interface {
	GetUploadMission(context.Context, *GetUploadMissionRequest) (*UploadMission, error)
	// contains filtered or unexported methods
}

UploadMissionEdgeServiceServer is the server API for UploadMissionEdgeService service. All implementations must embed UnimplementedUploadMissionEdgeServiceServer for forward compatibility

type Vehicle 

type Vehicle struct {
	Id              string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name            string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	CommunicationId string `protobuf:"bytes,3,opt,name=communication_id,json=communicationId,proto3" json:"communication_id,omitempty"`
	// contains filtered or unexported fields
}

func (*Vehicle) Descriptor deprecated 

func (*Vehicle) Descriptor() ([]byte, []int)

Deprecated: Use Vehicle.ProtoReflect.Descriptor instead.

func (*Vehicle) GetCommunicationId 

func (x *Vehicle) GetCommunicationId() string

func (*Vehicle) GetId 

func (x *Vehicle) GetId() string

func (*Vehicle) GetName 

func (x *Vehicle) GetName() string

func (*Vehicle) ProtoMessage 

func (*Vehicle) ProtoMessage()

func (*Vehicle) ProtoReflect 

func (x *Vehicle) ProtoReflect() protoreflect.Message

func (*Vehicle) Reset 

func (x *Vehicle) Reset()

func (*Vehicle) String 

func (x *Vehicle) String() string

type VehicleCopiedEvent 

type VehicleCopiedEvent struct {
	FleetId           string `protobuf:"bytes,1,opt,name=fleet_id,json=fleetId,proto3" json:"fleet_id,omitempty"`
	OriginalVehicleId string `protobuf:"bytes,2,opt,name=original_vehicle_id,json=originalVehicleId,proto3" json:"original_vehicle_id,omitempty"`
	NewVehicleId      string `protobuf:"bytes,3,opt,name=new_vehicle_id,json=newVehicleId,proto3" json:"new_vehicle_id,omitempty"`
	// contains filtered or unexported fields
}

func (*VehicleCopiedEvent) Descriptor deprecated 

func (*VehicleCopiedEvent) Descriptor() ([]byte, []int)

Deprecated: Use VehicleCopiedEvent.ProtoReflect.Descriptor instead.

func (*VehicleCopiedEvent) GetFleetId 

func (x *VehicleCopiedEvent) GetFleetId() string

func (*VehicleCopiedEvent) GetNewVehicleId 

func (x *VehicleCopiedEvent) GetNewVehicleId() string

func (*VehicleCopiedEvent) GetOriginalVehicleId 

func (x *VehicleCopiedEvent) GetOriginalVehicleId() string

func (*VehicleCopiedEvent) ProtoMessage 

func (*VehicleCopiedEvent) ProtoMessage()

func (*VehicleCopiedEvent) ProtoReflect 

func (x *VehicleCopiedEvent) ProtoReflect() protoreflect.Message

func (*VehicleCopiedEvent) Reset 

func (x *VehicleCopiedEvent) Reset()

func (*VehicleCopiedEvent) String 

func (x *VehicleCopiedEvent) String() string

type Waypoint 

type Waypoint struct {
	Latitude       float64 `protobuf:"fixed64,1,opt,name=latitude,proto3" json:"latitude,omitempty"`
	Longitude      float64 `protobuf:"fixed64,2,opt,name=longitude,proto3" json:"longitude,omitempty"`
	RelativeHeight float64 `protobuf:"fixed64,3,opt,name=relative_height,json=relativeHeight,proto3" json:"relative_height,omitempty"`
	Speed          float64 `protobuf:"fixed64,4,opt,name=speed,proto3" json:"speed,omitempty"`
	// contains filtered or unexported fields
}

func (*Waypoint) Descriptor deprecated 

func (*Waypoint) Descriptor() ([]byte, []int)

Deprecated: Use Waypoint.ProtoReflect.Descriptor instead.

func (*Waypoint) GetLatitude 

func (x *Waypoint) GetLatitude() float64

func (*Waypoint) GetLongitude 

func (x *Waypoint) GetLongitude() float64

func (*Waypoint) GetRelativeHeight 

func (x *Waypoint) GetRelativeHeight() float64

func (*Waypoint) GetSpeed 

func (x *Waypoint) GetSpeed() float64

func (*Waypoint) ProtoMessage 

func (*Waypoint) ProtoMessage()

func (*Waypoint) ProtoReflect 

func (x *Waypoint) ProtoReflect() protoreflect.Message

func (*Waypoint) Reset 

func (x *Waypoint) Reset()

func (*Waypoint) String 

func (x *Waypoint) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.