package cmvr.api;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 * <pre>
 * AGV 通用服务。该服务只暴露控制器无关的能力，
 * 厂商协议、地图文件格式和控制器特有参数由具体 AGV 适配器内部处理。
 * </pre>
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.52.0)",
    comments = "Source: cmvr/api/agv_service.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class AgvServiceGrpc {

  private AgvServiceGrpc() {}

  public static final String SERVICE_NAME = "cmvr.api.AgvService";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request,
      cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback> getGetRuntimeStateMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "getRuntimeState",
      requestType = cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request,
      cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback> getGetRuntimeStateMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request, cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback> getGetRuntimeStateMethod;
    if ((getGetRuntimeStateMethod = AgvServiceGrpc.getGetRuntimeStateMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getGetRuntimeStateMethod = AgvServiceGrpc.getGetRuntimeStateMethod) == null) {
          AgvServiceGrpc.getGetRuntimeStateMethod = getGetRuntimeStateMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request, cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "getRuntimeState"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("getRuntimeState"))
              .build();
        }
      }
    }
    return getGetRuntimeStateMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request,
      cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback> getGetNavigationStatusMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "getNavigationStatus",
      requestType = cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request,
      cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback> getGetNavigationStatusMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request, cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback> getGetNavigationStatusMethod;
    if ((getGetNavigationStatusMethod = AgvServiceGrpc.getGetNavigationStatusMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getGetNavigationStatusMethod = AgvServiceGrpc.getGetNavigationStatusMethod) == null) {
          AgvServiceGrpc.getGetNavigationStatusMethod = getGetNavigationStatusMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request, cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "getNavigationStatus"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("getNavigationStatus"))
              .build();
        }
      }
    }
    return getGetNavigationStatusMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getEmergencyStopMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "emergencyStop",
      requestType = cmvr.api.Common.CommandHeader.Request.class,
      responseType = cmvr.api.Common.CommandHeader.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getEmergencyStopMethod() {
    io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback> getEmergencyStopMethod;
    if ((getEmergencyStopMethod = AgvServiceGrpc.getEmergencyStopMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getEmergencyStopMethod = AgvServiceGrpc.getEmergencyStopMethod) == null) {
          AgvServiceGrpc.getEmergencyStopMethod = getEmergencyStopMethod =
              io.grpc.MethodDescriptor.<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "emergencyStop"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("emergencyStop"))
              .build();
        }
      }
    }
    return getEmergencyStopMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getClearFaultMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "clearFault",
      requestType = cmvr.api.Common.CommandHeader.Request.class,
      responseType = cmvr.api.Common.CommandHeader.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getClearFaultMethod() {
    io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback> getClearFaultMethod;
    if ((getClearFaultMethod = AgvServiceGrpc.getClearFaultMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getClearFaultMethod = AgvServiceGrpc.getClearFaultMethod) == null) {
          AgvServiceGrpc.getClearFaultMethod = getClearFaultMethod =
              io.grpc.MethodDescriptor.<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "clearFault"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("clearFault"))
              .build();
        }
      }
    }
    return getClearFaultMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request,
      cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback> getNavigateToPoseMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "navigateToPose",
      requestType = cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request,
      cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback> getNavigateToPoseMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request, cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback> getNavigateToPoseMethod;
    if ((getNavigateToPoseMethod = AgvServiceGrpc.getNavigateToPoseMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getNavigateToPoseMethod = AgvServiceGrpc.getNavigateToPoseMethod) == null) {
          AgvServiceGrpc.getNavigateToPoseMethod = getNavigateToPoseMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request, cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "navigateToPose"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("navigateToPose"))
              .build();
        }
      }
    }
    return getNavigateToPoseMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request,
      cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback> getNavigateToStationMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "navigateToStation",
      requestType = cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request,
      cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback> getNavigateToStationMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request, cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback> getNavigateToStationMethod;
    if ((getNavigateToStationMethod = AgvServiceGrpc.getNavigateToStationMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getNavigateToStationMethod = AgvServiceGrpc.getNavigateToStationMethod) == null) {
          AgvServiceGrpc.getNavigateToStationMethod = getNavigateToStationMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request, cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "navigateToStation"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("navigateToStation"))
              .build();
        }
      }
    }
    return getNavigateToStationMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvFollowPathCommand.Request,
      cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback> getFollowPathMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "followPath",
      requestType = cmvr.api.AgvCommand.AgvFollowPathCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvFollowPathCommand.Request,
      cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback> getFollowPathMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvFollowPathCommand.Request, cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback> getFollowPathMethod;
    if ((getFollowPathMethod = AgvServiceGrpc.getFollowPathMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getFollowPathMethod = AgvServiceGrpc.getFollowPathMethod) == null) {
          AgvServiceGrpc.getFollowPathMethod = getFollowPathMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvFollowPathCommand.Request, cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "followPath"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvFollowPathCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("followPath"))
              .build();
        }
      }
    }
    return getFollowPathMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getPauseNavigationMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "pauseNavigation",
      requestType = cmvr.api.Common.CommandHeader.Request.class,
      responseType = cmvr.api.Common.CommandHeader.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getPauseNavigationMethod() {
    io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback> getPauseNavigationMethod;
    if ((getPauseNavigationMethod = AgvServiceGrpc.getPauseNavigationMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getPauseNavigationMethod = AgvServiceGrpc.getPauseNavigationMethod) == null) {
          AgvServiceGrpc.getPauseNavigationMethod = getPauseNavigationMethod =
              io.grpc.MethodDescriptor.<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "pauseNavigation"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("pauseNavigation"))
              .build();
        }
      }
    }
    return getPauseNavigationMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getResumeNavigationMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "resumeNavigation",
      requestType = cmvr.api.Common.CommandHeader.Request.class,
      responseType = cmvr.api.Common.CommandHeader.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getResumeNavigationMethod() {
    io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback> getResumeNavigationMethod;
    if ((getResumeNavigationMethod = AgvServiceGrpc.getResumeNavigationMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getResumeNavigationMethod = AgvServiceGrpc.getResumeNavigationMethod) == null) {
          AgvServiceGrpc.getResumeNavigationMethod = getResumeNavigationMethod =
              io.grpc.MethodDescriptor.<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "resumeNavigation"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("resumeNavigation"))
              .build();
        }
      }
    }
    return getResumeNavigationMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getCancelNavigationMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "cancelNavigation",
      requestType = cmvr.api.Common.CommandHeader.Request.class,
      responseType = cmvr.api.Common.CommandHeader.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getCancelNavigationMethod() {
    io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback> getCancelNavigationMethod;
    if ((getCancelNavigationMethod = AgvServiceGrpc.getCancelNavigationMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getCancelNavigationMethod = AgvServiceGrpc.getCancelNavigationMethod) == null) {
          AgvServiceGrpc.getCancelNavigationMethod = getCancelNavigationMethod =
              io.grpc.MethodDescriptor.<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "cancelNavigation"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("cancelNavigation"))
              .build();
        }
      }
    }
    return getCancelNavigationMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvSetVelocityCommand.Request,
      cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback> getSetVelocityMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "setVelocity",
      requestType = cmvr.api.AgvCommand.AgvSetVelocityCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvSetVelocityCommand.Request,
      cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback> getSetVelocityMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvSetVelocityCommand.Request, cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback> getSetVelocityMethod;
    if ((getSetVelocityMethod = AgvServiceGrpc.getSetVelocityMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getSetVelocityMethod = AgvServiceGrpc.getSetVelocityMethod) == null) {
          AgvServiceGrpc.getSetVelocityMethod = getSetVelocityMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvSetVelocityCommand.Request, cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "setVelocity"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvSetVelocityCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("setVelocity"))
              .build();
        }
      }
    }
    return getSetVelocityMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getStopVelocityControlMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "stopVelocityControl",
      requestType = cmvr.api.Common.CommandHeader.Request.class,
      responseType = cmvr.api.Common.CommandHeader.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getStopVelocityControlMethod() {
    io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback> getStopVelocityControlMethod;
    if ((getStopVelocityControlMethod = AgvServiceGrpc.getStopVelocityControlMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getStopVelocityControlMethod = AgvServiceGrpc.getStopVelocityControlMethod) == null) {
          AgvServiceGrpc.getStopVelocityControlMethod = getStopVelocityControlMethod =
              io.grpc.MethodDescriptor.<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "stopVelocityControl"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("stopVelocityControl"))
              .build();
        }
      }
    }
    return getStopVelocityControlMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvListMapsCommand.Request,
      cmvr.api.AgvCommand.AgvListMapsCommand.Feedback> getListMapsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "listMaps",
      requestType = cmvr.api.AgvCommand.AgvListMapsCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvListMapsCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvListMapsCommand.Request,
      cmvr.api.AgvCommand.AgvListMapsCommand.Feedback> getListMapsMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvListMapsCommand.Request, cmvr.api.AgvCommand.AgvListMapsCommand.Feedback> getListMapsMethod;
    if ((getListMapsMethod = AgvServiceGrpc.getListMapsMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getListMapsMethod = AgvServiceGrpc.getListMapsMethod) == null) {
          AgvServiceGrpc.getListMapsMethod = getListMapsMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvListMapsCommand.Request, cmvr.api.AgvCommand.AgvListMapsCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "listMaps"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvListMapsCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvListMapsCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("listMaps"))
              .build();
        }
      }
    }
    return getListMapsMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvListStationsCommand.Request,
      cmvr.api.AgvCommand.AgvListStationsCommand.Feedback> getListStationsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "listStations",
      requestType = cmvr.api.AgvCommand.AgvListStationsCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvListStationsCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvListStationsCommand.Request,
      cmvr.api.AgvCommand.AgvListStationsCommand.Feedback> getListStationsMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvListStationsCommand.Request, cmvr.api.AgvCommand.AgvListStationsCommand.Feedback> getListStationsMethod;
    if ((getListStationsMethod = AgvServiceGrpc.getListStationsMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getListStationsMethod = AgvServiceGrpc.getListStationsMethod) == null) {
          AgvServiceGrpc.getListStationsMethod = getListStationsMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvListStationsCommand.Request, cmvr.api.AgvCommand.AgvListStationsCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "listStations"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvListStationsCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvListStationsCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("listStations"))
              .build();
        }
      }
    }
    return getListStationsMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapCommand.Request,
      cmvr.api.AgvCommand.AgvMapCommand.Feedback> getSwitchMapMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "switchMap",
      requestType = cmvr.api.AgvCommand.AgvMapCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvMapCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapCommand.Request,
      cmvr.api.AgvCommand.AgvMapCommand.Feedback> getSwitchMapMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapCommand.Request, cmvr.api.AgvCommand.AgvMapCommand.Feedback> getSwitchMapMethod;
    if ((getSwitchMapMethod = AgvServiceGrpc.getSwitchMapMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getSwitchMapMethod = AgvServiceGrpc.getSwitchMapMethod) == null) {
          AgvServiceGrpc.getSwitchMapMethod = getSwitchMapMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvMapCommand.Request, cmvr.api.AgvCommand.AgvMapCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "switchMap"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvMapCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvMapCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("switchMap"))
              .build();
        }
      }
    }
    return getSwitchMapMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapCommand.Request,
      cmvr.api.AgvCommand.AgvMapCommand.Feedback> getUploadMapMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "uploadMap",
      requestType = cmvr.api.AgvCommand.AgvMapCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvMapCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapCommand.Request,
      cmvr.api.AgvCommand.AgvMapCommand.Feedback> getUploadMapMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapCommand.Request, cmvr.api.AgvCommand.AgvMapCommand.Feedback> getUploadMapMethod;
    if ((getUploadMapMethod = AgvServiceGrpc.getUploadMapMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getUploadMapMethod = AgvServiceGrpc.getUploadMapMethod) == null) {
          AgvServiceGrpc.getUploadMapMethod = getUploadMapMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvMapCommand.Request, cmvr.api.AgvCommand.AgvMapCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "uploadMap"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvMapCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvMapCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("uploadMap"))
              .build();
        }
      }
    }
    return getUploadMapMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapCommand.Request,
      cmvr.api.AgvCommand.AgvMapCommand.Feedback> getDownloadMapMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "downloadMap",
      requestType = cmvr.api.AgvCommand.AgvMapCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvMapCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapCommand.Request,
      cmvr.api.AgvCommand.AgvMapCommand.Feedback> getDownloadMapMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapCommand.Request, cmvr.api.AgvCommand.AgvMapCommand.Feedback> getDownloadMapMethod;
    if ((getDownloadMapMethod = AgvServiceGrpc.getDownloadMapMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getDownloadMapMethod = AgvServiceGrpc.getDownloadMapMethod) == null) {
          AgvServiceGrpc.getDownloadMapMethod = getDownloadMapMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvMapCommand.Request, cmvr.api.AgvCommand.AgvMapCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "downloadMap"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvMapCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvMapCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("downloadMap"))
              .build();
        }
      }
    }
    return getDownloadMapMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvStartMappingCommand.Request,
      cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback> getStartMappingMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "startMapping",
      requestType = cmvr.api.AgvCommand.AgvStartMappingCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvStartMappingCommand.Request,
      cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback> getStartMappingMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvStartMappingCommand.Request, cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback> getStartMappingMethod;
    if ((getStartMappingMethod = AgvServiceGrpc.getStartMappingMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getStartMappingMethod = AgvServiceGrpc.getStartMappingMethod) == null) {
          AgvServiceGrpc.getStartMappingMethod = getStartMappingMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvStartMappingCommand.Request, cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "startMapping"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvStartMappingCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("startMapping"))
              .build();
        }
      }
    }
    return getStartMappingMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapStreamCommand.Request,
      cmvr.api.AgvCommand.AgvMapStreamCommand.Feedback> getStreamMapMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "streamMap",
      requestType = cmvr.api.AgvCommand.AgvMapStreamCommand.Request.class,
      responseType = cmvr.api.AgvCommand.AgvMapStreamCommand.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
  public static io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapStreamCommand.Request,
      cmvr.api.AgvCommand.AgvMapStreamCommand.Feedback> getStreamMapMethod() {
    io.grpc.MethodDescriptor<cmvr.api.AgvCommand.AgvMapStreamCommand.Request, cmvr.api.AgvCommand.AgvMapStreamCommand.Feedback> getStreamMapMethod;
    if ((getStreamMapMethod = AgvServiceGrpc.getStreamMapMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getStreamMapMethod = AgvServiceGrpc.getStreamMapMethod) == null) {
          AgvServiceGrpc.getStreamMapMethod = getStreamMapMethod =
              io.grpc.MethodDescriptor.<cmvr.api.AgvCommand.AgvMapStreamCommand.Request, cmvr.api.AgvCommand.AgvMapStreamCommand.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "streamMap"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvMapStreamCommand.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.AgvCommand.AgvMapStreamCommand.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("streamMap"))
              .build();
        }
      }
    }
    return getStreamMapMethod;
  }

  private static volatile io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getStopMappingMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "stopMapping",
      requestType = cmvr.api.Common.CommandHeader.Request.class,
      responseType = cmvr.api.Common.CommandHeader.Feedback.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request,
      cmvr.api.Common.CommandHeader.Feedback> getStopMappingMethod() {
    io.grpc.MethodDescriptor<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback> getStopMappingMethod;
    if ((getStopMappingMethod = AgvServiceGrpc.getStopMappingMethod) == null) {
      synchronized (AgvServiceGrpc.class) {
        if ((getStopMappingMethod = AgvServiceGrpc.getStopMappingMethod) == null) {
          AgvServiceGrpc.getStopMappingMethod = getStopMappingMethod =
              io.grpc.MethodDescriptor.<cmvr.api.Common.CommandHeader.Request, cmvr.api.Common.CommandHeader.Feedback>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "stopMapping"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Request.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  cmvr.api.Common.CommandHeader.Feedback.getDefaultInstance()))
              .setSchemaDescriptor(new AgvServiceMethodDescriptorSupplier("stopMapping"))
              .build();
        }
      }
    }
    return getStopMappingMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static AgvServiceStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<AgvServiceStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<AgvServiceStub>() {
        @java.lang.Override
        public AgvServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new AgvServiceStub(channel, callOptions);
        }
      };
    return AgvServiceStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static AgvServiceBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<AgvServiceBlockingStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<AgvServiceBlockingStub>() {
        @java.lang.Override
        public AgvServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new AgvServiceBlockingStub(channel, callOptions);
        }
      };
    return AgvServiceBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static AgvServiceFutureStub newFutureStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<AgvServiceFutureStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<AgvServiceFutureStub>() {
        @java.lang.Override
        public AgvServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new AgvServiceFutureStub(channel, callOptions);
        }
      };
    return AgvServiceFutureStub.newStub(factory, channel);
  }

  /**
   * <pre>
   * AGV 通用服务。该服务只暴露控制器无关的能力，
   * 厂商协议、地图文件格式和控制器特有参数由具体 AGV 适配器内部处理。
   * </pre>
   */
  public static abstract class AgvServiceImplBase implements io.grpc.BindableService {

    /**
     * <pre>
     * 获取 AGV 当前运行状态快照。
     * </pre>
     */
    public void getRuntimeState(cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetRuntimeStateMethod(), responseObserver);
    }

    /**
     * <pre>
     * 获取当前导航任务状态。
     * </pre>
     */
    public void getNavigationStatus(cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetNavigationStatusMethod(), responseObserver);
    }

    /**
     * <pre>
     * 执行急停或等效安全停止动作。
     * </pre>
     */
    public void emergencyStop(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getEmergencyStopMethod(), responseObserver);
    }

    /**
     * <pre>
     * 清除可恢复故障或告警。
     * </pre>
     */
    public void clearFault(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getClearFaultMethod(), responseObserver);
    }

    /**
     * <pre>
     * 导航到指定地图位姿。目标位姿 x/y 单位为米，theta 单位为弧度。
     * </pre>
     */
    public void navigateToPose(cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getNavigateToPoseMethod(), responseObserver);
    }

    /**
     * <pre>
     * 导航到指定地图站点。
     * </pre>
     */
    public void navigateToStation(cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getNavigateToStationMethod(), responseObserver);
    }

    /**
     * <pre>
     * 按显式站点路径执行导航。
     * </pre>
     */
    public void followPath(cmvr.api.AgvCommand.AgvFollowPathCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getFollowPathMethod(), responseObserver);
    }

    /**
     * <pre>
     * 暂停当前导航任务。
     * </pre>
     */
    public void pauseNavigation(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPauseNavigationMethod(), responseObserver);
    }

    /**
     * <pre>
     * 恢复已暂停的导航任务。
     * </pre>
     */
    public void resumeNavigation(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getResumeNavigationMethod(), responseObserver);
    }

    /**
     * <pre>
     * 取消当前导航任务。
     * </pre>
     */
    public void cancelNavigation(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCancelNavigationMethod(), responseObserver);
    }

    /**
     * <pre>
     * 下发底盘速度控制指令。vx/vy 单位为米/秒，wz 单位为弧度/秒。
     * </pre>
     */
    public void setVelocity(cmvr.api.AgvCommand.AgvSetVelocityCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetVelocityMethod(), responseObserver);
    }

    /**
     * <pre>
     * 停止底盘速度控制。该接口不等价于取消导航任务。
     * </pre>
     */
    public void stopVelocityControl(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStopVelocityControlMethod(), responseObserver);
    }

    /**
     * <pre>
     * 查询 AGV 控制器可用地图名称列表。
     * </pre>
     */
    public void listMaps(cmvr.api.AgvCommand.AgvListMapsCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvListMapsCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListMapsMethod(), responseObserver);
    }

    /**
     * <pre>
     * 查询当前地图中的站点列表。
     * </pre>
     */
    public void listStations(cmvr.api.AgvCommand.AgvListStationsCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvListStationsCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListStationsMethod(), responseObserver);
    }

    /**
     * <pre>
     * 切换当前使用地图。
     * </pre>
     */
    public void switchMap(cmvr.api.AgvCommand.AgvMapCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSwitchMapMethod(), responseObserver);
    }

    /**
     * <pre>
     * 上传地图内容到 AGV 控制器。地图内容字段由适配器解释。
     * </pre>
     */
    public void uploadMap(cmvr.api.AgvCommand.AgvMapCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUploadMapMethod(), responseObserver);
    }

    /**
     * <pre>
     * 下载指定地图内容。
     * </pre>
     */
    public void downloadMap(cmvr.api.AgvCommand.AgvMapCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDownloadMapMethod(), responseObserver);
    }

    /**
     * <pre>
     * 开始建图/扫图会话。请求只选择 2D、3D 或二者都要，
     * 控制器特有地图格式由 AGV 适配器内部转换。
     * </pre>
     */
    public void startMapping(cmvr.api.AgvCommand.AgvStartMappingCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStartMappingMethod(), responseObserver);
    }

    /**
     * <pre>
     * 以服务端流方式发送统一地图。resume_token 为空时应先发送全量快照；
     * 后续是否发送增量由 AGV 适配器能力决定，并通过 update_type 标记。
     * </pre>
     */
    public void streamMap(cmvr.api.AgvCommand.AgvMapStreamCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapStreamCommand.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStreamMapMethod(), responseObserver);
    }

    /**
     * <pre>
     * 停止当前建图/扫图会话。
     * </pre>
     */
    public void stopMapping(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStopMappingMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getGetRuntimeStateMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request,
                cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback>(
                  this, METHODID_GET_RUNTIME_STATE)))
          .addMethod(
            getGetNavigationStatusMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request,
                cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback>(
                  this, METHODID_GET_NAVIGATION_STATUS)))
          .addMethod(
            getEmergencyStopMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.Common.CommandHeader.Request,
                cmvr.api.Common.CommandHeader.Feedback>(
                  this, METHODID_EMERGENCY_STOP)))
          .addMethod(
            getClearFaultMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.Common.CommandHeader.Request,
                cmvr.api.Common.CommandHeader.Feedback>(
                  this, METHODID_CLEAR_FAULT)))
          .addMethod(
            getNavigateToPoseMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request,
                cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback>(
                  this, METHODID_NAVIGATE_TO_POSE)))
          .addMethod(
            getNavigateToStationMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request,
                cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback>(
                  this, METHODID_NAVIGATE_TO_STATION)))
          .addMethod(
            getFollowPathMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvFollowPathCommand.Request,
                cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback>(
                  this, METHODID_FOLLOW_PATH)))
          .addMethod(
            getPauseNavigationMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.Common.CommandHeader.Request,
                cmvr.api.Common.CommandHeader.Feedback>(
                  this, METHODID_PAUSE_NAVIGATION)))
          .addMethod(
            getResumeNavigationMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.Common.CommandHeader.Request,
                cmvr.api.Common.CommandHeader.Feedback>(
                  this, METHODID_RESUME_NAVIGATION)))
          .addMethod(
            getCancelNavigationMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.Common.CommandHeader.Request,
                cmvr.api.Common.CommandHeader.Feedback>(
                  this, METHODID_CANCEL_NAVIGATION)))
          .addMethod(
            getSetVelocityMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvSetVelocityCommand.Request,
                cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback>(
                  this, METHODID_SET_VELOCITY)))
          .addMethod(
            getStopVelocityControlMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.Common.CommandHeader.Request,
                cmvr.api.Common.CommandHeader.Feedback>(
                  this, METHODID_STOP_VELOCITY_CONTROL)))
          .addMethod(
            getListMapsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvListMapsCommand.Request,
                cmvr.api.AgvCommand.AgvListMapsCommand.Feedback>(
                  this, METHODID_LIST_MAPS)))
          .addMethod(
            getListStationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvListStationsCommand.Request,
                cmvr.api.AgvCommand.AgvListStationsCommand.Feedback>(
                  this, METHODID_LIST_STATIONS)))
          .addMethod(
            getSwitchMapMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvMapCommand.Request,
                cmvr.api.AgvCommand.AgvMapCommand.Feedback>(
                  this, METHODID_SWITCH_MAP)))
          .addMethod(
            getUploadMapMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvMapCommand.Request,
                cmvr.api.AgvCommand.AgvMapCommand.Feedback>(
                  this, METHODID_UPLOAD_MAP)))
          .addMethod(
            getDownloadMapMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvMapCommand.Request,
                cmvr.api.AgvCommand.AgvMapCommand.Feedback>(
                  this, METHODID_DOWNLOAD_MAP)))
          .addMethod(
            getStartMappingMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvStartMappingCommand.Request,
                cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback>(
                  this, METHODID_START_MAPPING)))
          .addMethod(
            getStreamMapMethod(),
            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
              new MethodHandlers<
                cmvr.api.AgvCommand.AgvMapStreamCommand.Request,
                cmvr.api.AgvCommand.AgvMapStreamCommand.Feedback>(
                  this, METHODID_STREAM_MAP)))
          .addMethod(
            getStopMappingMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                cmvr.api.Common.CommandHeader.Request,
                cmvr.api.Common.CommandHeader.Feedback>(
                  this, METHODID_STOP_MAPPING)))
          .build();
    }
  }

  /**
   * <pre>
   * AGV 通用服务。该服务只暴露控制器无关的能力，
   * 厂商协议、地图文件格式和控制器特有参数由具体 AGV 适配器内部处理。
   * </pre>
   */
  public static final class AgvServiceStub extends io.grpc.stub.AbstractAsyncStub<AgvServiceStub> {
    private AgvServiceStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected AgvServiceStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new AgvServiceStub(channel, callOptions);
    }

    /**
     * <pre>
     * 获取 AGV 当前运行状态快照。
     * </pre>
     */
    public void getRuntimeState(cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetRuntimeStateMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 获取当前导航任务状态。
     * </pre>
     */
    public void getNavigationStatus(cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetNavigationStatusMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 执行急停或等效安全停止动作。
     * </pre>
     */
    public void emergencyStop(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getEmergencyStopMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 清除可恢复故障或告警。
     * </pre>
     */
    public void clearFault(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getClearFaultMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 导航到指定地图位姿。目标位姿 x/y 单位为米，theta 单位为弧度。
     * </pre>
     */
    public void navigateToPose(cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getNavigateToPoseMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 导航到指定地图站点。
     * </pre>
     */
    public void navigateToStation(cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getNavigateToStationMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 按显式站点路径执行导航。
     * </pre>
     */
    public void followPath(cmvr.api.AgvCommand.AgvFollowPathCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getFollowPathMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 暂停当前导航任务。
     * </pre>
     */
    public void pauseNavigation(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPauseNavigationMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 恢复已暂停的导航任务。
     * </pre>
     */
    public void resumeNavigation(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getResumeNavigationMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 取消当前导航任务。
     * </pre>
     */
    public void cancelNavigation(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCancelNavigationMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 下发底盘速度控制指令。vx/vy 单位为米/秒，wz 单位为弧度/秒。
     * </pre>
     */
    public void setVelocity(cmvr.api.AgvCommand.AgvSetVelocityCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetVelocityMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 停止底盘速度控制。该接口不等价于取消导航任务。
     * </pre>
     */
    public void stopVelocityControl(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getStopVelocityControlMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 查询 AGV 控制器可用地图名称列表。
     * </pre>
     */
    public void listMaps(cmvr.api.AgvCommand.AgvListMapsCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvListMapsCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListMapsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 查询当前地图中的站点列表。
     * </pre>
     */
    public void listStations(cmvr.api.AgvCommand.AgvListStationsCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvListStationsCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListStationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 切换当前使用地图。
     * </pre>
     */
    public void switchMap(cmvr.api.AgvCommand.AgvMapCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSwitchMapMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 上传地图内容到 AGV 控制器。地图内容字段由适配器解释。
     * </pre>
     */
    public void uploadMap(cmvr.api.AgvCommand.AgvMapCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUploadMapMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 下载指定地图内容。
     * </pre>
     */
    public void downloadMap(cmvr.api.AgvCommand.AgvMapCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDownloadMapMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 开始建图/扫图会话。请求只选择 2D、3D 或二者都要，
     * 控制器特有地图格式由 AGV 适配器内部转换。
     * </pre>
     */
    public void startMapping(cmvr.api.AgvCommand.AgvStartMappingCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getStartMappingMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 以服务端流方式发送统一地图。resume_token 为空时应先发送全量快照；
     * 后续是否发送增量由 AGV 适配器能力决定，并通过 update_type 标记。
     * </pre>
     */
    public void streamMap(cmvr.api.AgvCommand.AgvMapStreamCommand.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapStreamCommand.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
          getChannel().newCall(getStreamMapMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 停止当前建图/扫图会话。
     * </pre>
     */
    public void stopMapping(cmvr.api.Common.CommandHeader.Request request,
        io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getStopMappingMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   * <pre>
   * AGV 通用服务。该服务只暴露控制器无关的能力，
   * 厂商协议、地图文件格式和控制器特有参数由具体 AGV 适配器内部处理。
   * </pre>
   */
  public static final class AgvServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<AgvServiceBlockingStub> {
    private AgvServiceBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected AgvServiceBlockingStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new AgvServiceBlockingStub(channel, callOptions);
    }

    /**
     * <pre>
     * 获取 AGV 当前运行状态快照。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback getRuntimeState(cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetRuntimeStateMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 获取当前导航任务状态。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback getNavigationStatus(cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetNavigationStatusMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 执行急停或等效安全停止动作。
     * </pre>
     */
    public cmvr.api.Common.CommandHeader.Feedback emergencyStop(cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getEmergencyStopMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 清除可恢复故障或告警。
     * </pre>
     */
    public cmvr.api.Common.CommandHeader.Feedback clearFault(cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getClearFaultMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 导航到指定地图位姿。目标位姿 x/y 单位为米，theta 单位为弧度。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback navigateToPose(cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getNavigateToPoseMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 导航到指定地图站点。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback navigateToStation(cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getNavigateToStationMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 按显式站点路径执行导航。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback followPath(cmvr.api.AgvCommand.AgvFollowPathCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getFollowPathMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 暂停当前导航任务。
     * </pre>
     */
    public cmvr.api.Common.CommandHeader.Feedback pauseNavigation(cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPauseNavigationMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 恢复已暂停的导航任务。
     * </pre>
     */
    public cmvr.api.Common.CommandHeader.Feedback resumeNavigation(cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getResumeNavigationMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 取消当前导航任务。
     * </pre>
     */
    public cmvr.api.Common.CommandHeader.Feedback cancelNavigation(cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCancelNavigationMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 下发底盘速度控制指令。vx/vy 单位为米/秒，wz 单位为弧度/秒。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback setVelocity(cmvr.api.AgvCommand.AgvSetVelocityCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetVelocityMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 停止底盘速度控制。该接口不等价于取消导航任务。
     * </pre>
     */
    public cmvr.api.Common.CommandHeader.Feedback stopVelocityControl(cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getStopVelocityControlMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 查询 AGV 控制器可用地图名称列表。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvListMapsCommand.Feedback listMaps(cmvr.api.AgvCommand.AgvListMapsCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListMapsMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 查询当前地图中的站点列表。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvListStationsCommand.Feedback listStations(cmvr.api.AgvCommand.AgvListStationsCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListStationsMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 切换当前使用地图。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvMapCommand.Feedback switchMap(cmvr.api.AgvCommand.AgvMapCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSwitchMapMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 上传地图内容到 AGV 控制器。地图内容字段由适配器解释。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvMapCommand.Feedback uploadMap(cmvr.api.AgvCommand.AgvMapCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUploadMapMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 下载指定地图内容。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvMapCommand.Feedback downloadMap(cmvr.api.AgvCommand.AgvMapCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDownloadMapMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 开始建图/扫图会话。请求只选择 2D、3D 或二者都要，
     * 控制器特有地图格式由 AGV 适配器内部转换。
     * </pre>
     */
    public cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback startMapping(cmvr.api.AgvCommand.AgvStartMappingCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getStartMappingMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 以服务端流方式发送统一地图。resume_token 为空时应先发送全量快照；
     * 后续是否发送增量由 AGV 适配器能力决定，并通过 update_type 标记。
     * </pre>
     */
    public java.util.Iterator<cmvr.api.AgvCommand.AgvMapStreamCommand.Feedback> streamMap(
        cmvr.api.AgvCommand.AgvMapStreamCommand.Request request) {
      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
          getChannel(), getStreamMapMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 停止当前建图/扫图会话。
     * </pre>
     */
    public cmvr.api.Common.CommandHeader.Feedback stopMapping(cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getStopMappingMethod(), getCallOptions(), request);
    }
  }

  /**
   * <pre>
   * AGV 通用服务。该服务只暴露控制器无关的能力，
   * 厂商协议、地图文件格式和控制器特有参数由具体 AGV 适配器内部处理。
   * </pre>
   */
  public static final class AgvServiceFutureStub extends io.grpc.stub.AbstractFutureStub<AgvServiceFutureStub> {
    private AgvServiceFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected AgvServiceFutureStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new AgvServiceFutureStub(channel, callOptions);
    }

    /**
     * <pre>
     * 获取 AGV 当前运行状态快照。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback> getRuntimeState(
        cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetRuntimeStateMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 获取当前导航任务状态。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback> getNavigationStatus(
        cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetNavigationStatusMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 执行急停或等效安全停止动作。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.Common.CommandHeader.Feedback> emergencyStop(
        cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getEmergencyStopMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 清除可恢复故障或告警。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.Common.CommandHeader.Feedback> clearFault(
        cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getClearFaultMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 导航到指定地图位姿。目标位姿 x/y 单位为米，theta 单位为弧度。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback> navigateToPose(
        cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getNavigateToPoseMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 导航到指定地图站点。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback> navigateToStation(
        cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getNavigateToStationMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 按显式站点路径执行导航。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback> followPath(
        cmvr.api.AgvCommand.AgvFollowPathCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getFollowPathMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 暂停当前导航任务。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.Common.CommandHeader.Feedback> pauseNavigation(
        cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPauseNavigationMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 恢复已暂停的导航任务。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.Common.CommandHeader.Feedback> resumeNavigation(
        cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getResumeNavigationMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 取消当前导航任务。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.Common.CommandHeader.Feedback> cancelNavigation(
        cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCancelNavigationMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 下发底盘速度控制指令。vx/vy 单位为米/秒，wz 单位为弧度/秒。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback> setVelocity(
        cmvr.api.AgvCommand.AgvSetVelocityCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetVelocityMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 停止底盘速度控制。该接口不等价于取消导航任务。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.Common.CommandHeader.Feedback> stopVelocityControl(
        cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getStopVelocityControlMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 查询 AGV 控制器可用地图名称列表。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvListMapsCommand.Feedback> listMaps(
        cmvr.api.AgvCommand.AgvListMapsCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListMapsMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 查询当前地图中的站点列表。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvListStationsCommand.Feedback> listStations(
        cmvr.api.AgvCommand.AgvListStationsCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListStationsMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 切换当前使用地图。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvMapCommand.Feedback> switchMap(
        cmvr.api.AgvCommand.AgvMapCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSwitchMapMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 上传地图内容到 AGV 控制器。地图内容字段由适配器解释。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvMapCommand.Feedback> uploadMap(
        cmvr.api.AgvCommand.AgvMapCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUploadMapMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 下载指定地图内容。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvMapCommand.Feedback> downloadMap(
        cmvr.api.AgvCommand.AgvMapCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDownloadMapMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 开始建图/扫图会话。请求只选择 2D、3D 或二者都要，
     * 控制器特有地图格式由 AGV 适配器内部转换。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback> startMapping(
        cmvr.api.AgvCommand.AgvStartMappingCommand.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getStartMappingMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 停止当前建图/扫图会话。
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<cmvr.api.Common.CommandHeader.Feedback> stopMapping(
        cmvr.api.Common.CommandHeader.Request request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getStopMappingMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_GET_RUNTIME_STATE = 0;
  private static final int METHODID_GET_NAVIGATION_STATUS = 1;
  private static final int METHODID_EMERGENCY_STOP = 2;
  private static final int METHODID_CLEAR_FAULT = 3;
  private static final int METHODID_NAVIGATE_TO_POSE = 4;
  private static final int METHODID_NAVIGATE_TO_STATION = 5;
  private static final int METHODID_FOLLOW_PATH = 6;
  private static final int METHODID_PAUSE_NAVIGATION = 7;
  private static final int METHODID_RESUME_NAVIGATION = 8;
  private static final int METHODID_CANCEL_NAVIGATION = 9;
  private static final int METHODID_SET_VELOCITY = 10;
  private static final int METHODID_STOP_VELOCITY_CONTROL = 11;
  private static final int METHODID_LIST_MAPS = 12;
  private static final int METHODID_LIST_STATIONS = 13;
  private static final int METHODID_SWITCH_MAP = 14;
  private static final int METHODID_UPLOAD_MAP = 15;
  private static final int METHODID_DOWNLOAD_MAP = 16;
  private static final int METHODID_START_MAPPING = 17;
  private static final int METHODID_STREAM_MAP = 18;
  private static final int METHODID_STOP_MAPPING = 19;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final AgvServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(AgvServiceImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_GET_RUNTIME_STATE:
          serviceImpl.getRuntimeState((cmvr.api.AgvCommand.AgvRuntimeStateCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvRuntimeStateCommand.Feedback>) responseObserver);
          break;
        case METHODID_GET_NAVIGATION_STATUS:
          serviceImpl.getNavigationStatus((cmvr.api.AgvCommand.AgvNavigationStatusCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvNavigationStatusCommand.Feedback>) responseObserver);
          break;
        case METHODID_EMERGENCY_STOP:
          serviceImpl.emergencyStop((cmvr.api.Common.CommandHeader.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback>) responseObserver);
          break;
        case METHODID_CLEAR_FAULT:
          serviceImpl.clearFault((cmvr.api.Common.CommandHeader.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback>) responseObserver);
          break;
        case METHODID_NAVIGATE_TO_POSE:
          serviceImpl.navigateToPose((cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvNavigateToPoseCommand.Feedback>) responseObserver);
          break;
        case METHODID_NAVIGATE_TO_STATION:
          serviceImpl.navigateToStation((cmvr.api.AgvCommand.AgvNavigateToStationCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvNavigateToStationCommand.Feedback>) responseObserver);
          break;
        case METHODID_FOLLOW_PATH:
          serviceImpl.followPath((cmvr.api.AgvCommand.AgvFollowPathCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvFollowPathCommand.Feedback>) responseObserver);
          break;
        case METHODID_PAUSE_NAVIGATION:
          serviceImpl.pauseNavigation((cmvr.api.Common.CommandHeader.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback>) responseObserver);
          break;
        case METHODID_RESUME_NAVIGATION:
          serviceImpl.resumeNavigation((cmvr.api.Common.CommandHeader.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback>) responseObserver);
          break;
        case METHODID_CANCEL_NAVIGATION:
          serviceImpl.cancelNavigation((cmvr.api.Common.CommandHeader.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback>) responseObserver);
          break;
        case METHODID_SET_VELOCITY:
          serviceImpl.setVelocity((cmvr.api.AgvCommand.AgvSetVelocityCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvSetVelocityCommand.Feedback>) responseObserver);
          break;
        case METHODID_STOP_VELOCITY_CONTROL:
          serviceImpl.stopVelocityControl((cmvr.api.Common.CommandHeader.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback>) responseObserver);
          break;
        case METHODID_LIST_MAPS:
          serviceImpl.listMaps((cmvr.api.AgvCommand.AgvListMapsCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvListMapsCommand.Feedback>) responseObserver);
          break;
        case METHODID_LIST_STATIONS:
          serviceImpl.listStations((cmvr.api.AgvCommand.AgvListStationsCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvListStationsCommand.Feedback>) responseObserver);
          break;
        case METHODID_SWITCH_MAP:
          serviceImpl.switchMap((cmvr.api.AgvCommand.AgvMapCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapCommand.Feedback>) responseObserver);
          break;
        case METHODID_UPLOAD_MAP:
          serviceImpl.uploadMap((cmvr.api.AgvCommand.AgvMapCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapCommand.Feedback>) responseObserver);
          break;
        case METHODID_DOWNLOAD_MAP:
          serviceImpl.downloadMap((cmvr.api.AgvCommand.AgvMapCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapCommand.Feedback>) responseObserver);
          break;
        case METHODID_START_MAPPING:
          serviceImpl.startMapping((cmvr.api.AgvCommand.AgvStartMappingCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvStartMappingCommand.Feedback>) responseObserver);
          break;
        case METHODID_STREAM_MAP:
          serviceImpl.streamMap((cmvr.api.AgvCommand.AgvMapStreamCommand.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.AgvCommand.AgvMapStreamCommand.Feedback>) responseObserver);
          break;
        case METHODID_STOP_MAPPING:
          serviceImpl.stopMapping((cmvr.api.Common.CommandHeader.Request) request,
              (io.grpc.stub.StreamObserver<cmvr.api.Common.CommandHeader.Feedback>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  private static abstract class AgvServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    AgvServiceBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return cmvr.api.AgvServiceOuterClass.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("AgvService");
    }
  }

  private static final class AgvServiceFileDescriptorSupplier
      extends AgvServiceBaseDescriptorSupplier {
    AgvServiceFileDescriptorSupplier() {}
  }

  private static final class AgvServiceMethodDescriptorSupplier
      extends AgvServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    AgvServiceMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (AgvServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new AgvServiceFileDescriptorSupplier())
              .addMethod(getGetRuntimeStateMethod())
              .addMethod(getGetNavigationStatusMethod())
              .addMethod(getEmergencyStopMethod())
              .addMethod(getClearFaultMethod())
              .addMethod(getNavigateToPoseMethod())
              .addMethod(getNavigateToStationMethod())
              .addMethod(getFollowPathMethod())
              .addMethod(getPauseNavigationMethod())
              .addMethod(getResumeNavigationMethod())
              .addMethod(getCancelNavigationMethod())
              .addMethod(getSetVelocityMethod())
              .addMethod(getStopVelocityControlMethod())
              .addMethod(getListMapsMethod())
              .addMethod(getListStationsMethod())
              .addMethod(getSwitchMapMethod())
              .addMethod(getUploadMapMethod())
              .addMethod(getDownloadMapMethod())
              .addMethod(getStartMappingMethod())
              .addMethod(getStreamMapMethod())
              .addMethod(getStopMappingMethod())
              .build();
        }
      }
    }
    return result;
  }
}
