package monitoring;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.38.1)",
    comments = "Source: monitoring.proto")
public final class MonitoringServiceGrpc {

  private MonitoringServiceGrpc() {}

  public static final String SERVICE_NAME = "monitoring.MonitoringService";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.KpiDescriptor,
      monitoring.Monitoring.KpiId> getSetKpiMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SetKpi",
      requestType = monitoring.Monitoring.KpiDescriptor.class,
      responseType = monitoring.Monitoring.KpiId.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.KpiDescriptor,
      monitoring.Monitoring.KpiId> getSetKpiMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.KpiDescriptor, monitoring.Monitoring.KpiId> getSetKpiMethod;
    if ((getSetKpiMethod = MonitoringServiceGrpc.getSetKpiMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getSetKpiMethod = MonitoringServiceGrpc.getSetKpiMethod) == null) {
          MonitoringServiceGrpc.getSetKpiMethod = getSetKpiMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.KpiDescriptor, monitoring.Monitoring.KpiId>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetKpi"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.KpiDescriptor.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.KpiId.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("SetKpi"))
              .build();
        }
      }
    }
    return getSetKpiMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId,
      context.ContextOuterClass.Empty> getDeleteKpiMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteKpi",
      requestType = monitoring.Monitoring.KpiId.class,
      responseType = context.ContextOuterClass.Empty.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId,
      context.ContextOuterClass.Empty> getDeleteKpiMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId, context.ContextOuterClass.Empty> getDeleteKpiMethod;
    if ((getDeleteKpiMethod = MonitoringServiceGrpc.getDeleteKpiMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getDeleteKpiMethod = MonitoringServiceGrpc.getDeleteKpiMethod) == null) {
          MonitoringServiceGrpc.getDeleteKpiMethod = getDeleteKpiMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.KpiId, context.ContextOuterClass.Empty>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteKpi"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.KpiId.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  context.ContextOuterClass.Empty.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("DeleteKpi"))
              .build();
        }
      }
    }
    return getDeleteKpiMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId,
      monitoring.Monitoring.KpiDescriptor> getGetKpiDescriptorMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetKpiDescriptor",
      requestType = monitoring.Monitoring.KpiId.class,
      responseType = monitoring.Monitoring.KpiDescriptor.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId,
      monitoring.Monitoring.KpiDescriptor> getGetKpiDescriptorMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId, monitoring.Monitoring.KpiDescriptor> getGetKpiDescriptorMethod;
    if ((getGetKpiDescriptorMethod = MonitoringServiceGrpc.getGetKpiDescriptorMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getGetKpiDescriptorMethod = MonitoringServiceGrpc.getGetKpiDescriptorMethod) == null) {
          MonitoringServiceGrpc.getGetKpiDescriptorMethod = getGetKpiDescriptorMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.KpiId, monitoring.Monitoring.KpiDescriptor>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetKpiDescriptor"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.KpiId.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.KpiDescriptor.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("GetKpiDescriptor"))
              .build();
        }
      }
    }
    return getGetKpiDescriptorMethod;
  }

  private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
      monitoring.Monitoring.KpiDescriptorList> getGetKpiDescriptorListMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetKpiDescriptorList",
      requestType = context.ContextOuterClass.Empty.class,
      responseType = monitoring.Monitoring.KpiDescriptorList.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
      monitoring.Monitoring.KpiDescriptorList> getGetKpiDescriptorListMethod() {
    io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, monitoring.Monitoring.KpiDescriptorList> getGetKpiDescriptorListMethod;
    if ((getGetKpiDescriptorListMethod = MonitoringServiceGrpc.getGetKpiDescriptorListMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getGetKpiDescriptorListMethod = MonitoringServiceGrpc.getGetKpiDescriptorListMethod) == null) {
          MonitoringServiceGrpc.getGetKpiDescriptorListMethod = getGetKpiDescriptorListMethod =
              io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, monitoring.Monitoring.KpiDescriptorList>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetKpiDescriptorList"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  context.ContextOuterClass.Empty.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.KpiDescriptorList.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("GetKpiDescriptorList"))
              .build();
        }
      }
    }
    return getGetKpiDescriptorListMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.Kpi,
      context.ContextOuterClass.Empty> getIncludeKpiMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "IncludeKpi",
      requestType = monitoring.Monitoring.Kpi.class,
      responseType = context.ContextOuterClass.Empty.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.Kpi,
      context.ContextOuterClass.Empty> getIncludeKpiMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.Kpi, context.ContextOuterClass.Empty> getIncludeKpiMethod;
    if ((getIncludeKpiMethod = MonitoringServiceGrpc.getIncludeKpiMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getIncludeKpiMethod = MonitoringServiceGrpc.getIncludeKpiMethod) == null) {
          MonitoringServiceGrpc.getIncludeKpiMethod = getIncludeKpiMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.Kpi, context.ContextOuterClass.Empty>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "IncludeKpi"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.Kpi.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  context.ContextOuterClass.Empty.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("IncludeKpi"))
              .build();
        }
      }
    }
    return getIncludeKpiMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.MonitorKpiRequest,
      context.ContextOuterClass.Empty> getMonitorKpiMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "MonitorKpi",
      requestType = monitoring.Monitoring.MonitorKpiRequest.class,
      responseType = context.ContextOuterClass.Empty.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.MonitorKpiRequest,
      context.ContextOuterClass.Empty> getMonitorKpiMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.MonitorKpiRequest, context.ContextOuterClass.Empty> getMonitorKpiMethod;
    if ((getMonitorKpiMethod = MonitoringServiceGrpc.getMonitorKpiMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getMonitorKpiMethod = MonitoringServiceGrpc.getMonitorKpiMethod) == null) {
          MonitoringServiceGrpc.getMonitorKpiMethod = getMonitorKpiMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.MonitorKpiRequest, context.ContextOuterClass.Empty>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "MonitorKpi"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.MonitorKpiRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  context.ContextOuterClass.Empty.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("MonitorKpi"))
              .build();
        }
      }
    }
    return getMonitorKpiMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.KpiQuery,
      monitoring.Monitoring.RawKpiTable> getQueryKpiDataMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "QueryKpiData",
      requestType = monitoring.Monitoring.KpiQuery.class,
      responseType = monitoring.Monitoring.RawKpiTable.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.KpiQuery,
      monitoring.Monitoring.RawKpiTable> getQueryKpiDataMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.KpiQuery, monitoring.Monitoring.RawKpiTable> getQueryKpiDataMethod;
    if ((getQueryKpiDataMethod = MonitoringServiceGrpc.getQueryKpiDataMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getQueryKpiDataMethod = MonitoringServiceGrpc.getQueryKpiDataMethod) == null) {
          MonitoringServiceGrpc.getQueryKpiDataMethod = getQueryKpiDataMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.KpiQuery, monitoring.Monitoring.RawKpiTable>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "QueryKpiData"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.KpiQuery.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.RawKpiTable.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("QueryKpiData"))
              .build();
        }
      }
    }
    return getQueryKpiDataMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.SubsDescriptor,
      monitoring.Monitoring.SubsResponse> getSetKpiSubscriptionMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SetKpiSubscription",
      requestType = monitoring.Monitoring.SubsDescriptor.class,
      responseType = monitoring.Monitoring.SubsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.SubsDescriptor,
      monitoring.Monitoring.SubsResponse> getSetKpiSubscriptionMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.SubsDescriptor, monitoring.Monitoring.SubsResponse> getSetKpiSubscriptionMethod;
    if ((getSetKpiSubscriptionMethod = MonitoringServiceGrpc.getSetKpiSubscriptionMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getSetKpiSubscriptionMethod = MonitoringServiceGrpc.getSetKpiSubscriptionMethod) == null) {
          MonitoringServiceGrpc.getSetKpiSubscriptionMethod = getSetKpiSubscriptionMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.SubsDescriptor, monitoring.Monitoring.SubsResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetKpiSubscription"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.SubsDescriptor.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.SubsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("SetKpiSubscription"))
              .build();
        }
      }
    }
    return getSetKpiSubscriptionMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.SubscriptionID,
      monitoring.Monitoring.SubsDescriptor> getGetSubsDescriptorMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetSubsDescriptor",
      requestType = monitoring.Monitoring.SubscriptionID.class,
      responseType = monitoring.Monitoring.SubsDescriptor.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.SubscriptionID,
      monitoring.Monitoring.SubsDescriptor> getGetSubsDescriptorMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.SubscriptionID, monitoring.Monitoring.SubsDescriptor> getGetSubsDescriptorMethod;
    if ((getGetSubsDescriptorMethod = MonitoringServiceGrpc.getGetSubsDescriptorMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getGetSubsDescriptorMethod = MonitoringServiceGrpc.getGetSubsDescriptorMethod) == null) {
          MonitoringServiceGrpc.getGetSubsDescriptorMethod = getGetSubsDescriptorMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.SubscriptionID, monitoring.Monitoring.SubsDescriptor>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSubsDescriptor"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.SubscriptionID.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.SubsDescriptor.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("GetSubsDescriptor"))
              .build();
        }
      }
    }
    return getGetSubsDescriptorMethod;
  }

  private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
      monitoring.Monitoring.SubsList> getGetSubscriptionsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetSubscriptions",
      requestType = context.ContextOuterClass.Empty.class,
      responseType = monitoring.Monitoring.SubsList.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
      monitoring.Monitoring.SubsList> getGetSubscriptionsMethod() {
    io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, monitoring.Monitoring.SubsList> getGetSubscriptionsMethod;
    if ((getGetSubscriptionsMethod = MonitoringServiceGrpc.getGetSubscriptionsMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getGetSubscriptionsMethod = MonitoringServiceGrpc.getGetSubscriptionsMethod) == null) {
          MonitoringServiceGrpc.getGetSubscriptionsMethod = getGetSubscriptionsMethod =
              io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, monitoring.Monitoring.SubsList>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSubscriptions"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  context.ContextOuterClass.Empty.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.SubsList.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("GetSubscriptions"))
              .build();
        }
      }
    }
    return getGetSubscriptionsMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.SubscriptionID,
      context.ContextOuterClass.Empty> getDeleteSubscriptionMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteSubscription",
      requestType = monitoring.Monitoring.SubscriptionID.class,
      responseType = context.ContextOuterClass.Empty.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.SubscriptionID,
      context.ContextOuterClass.Empty> getDeleteSubscriptionMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.SubscriptionID, context.ContextOuterClass.Empty> getDeleteSubscriptionMethod;
    if ((getDeleteSubscriptionMethod = MonitoringServiceGrpc.getDeleteSubscriptionMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getDeleteSubscriptionMethod = MonitoringServiceGrpc.getDeleteSubscriptionMethod) == null) {
          MonitoringServiceGrpc.getDeleteSubscriptionMethod = getDeleteSubscriptionMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.SubscriptionID, context.ContextOuterClass.Empty>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteSubscription"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.SubscriptionID.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  context.ContextOuterClass.Empty.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("DeleteSubscription"))
              .build();
        }
      }
    }
    return getDeleteSubscriptionMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmDescriptor,
      monitoring.Monitoring.AlarmID> getSetKpiAlarmMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SetKpiAlarm",
      requestType = monitoring.Monitoring.AlarmDescriptor.class,
      responseType = monitoring.Monitoring.AlarmID.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmDescriptor,
      monitoring.Monitoring.AlarmID> getSetKpiAlarmMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmDescriptor, monitoring.Monitoring.AlarmID> getSetKpiAlarmMethod;
    if ((getSetKpiAlarmMethod = MonitoringServiceGrpc.getSetKpiAlarmMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getSetKpiAlarmMethod = MonitoringServiceGrpc.getSetKpiAlarmMethod) == null) {
          MonitoringServiceGrpc.getSetKpiAlarmMethod = getSetKpiAlarmMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.AlarmDescriptor, monitoring.Monitoring.AlarmID>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetKpiAlarm"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.AlarmDescriptor.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.AlarmID.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("SetKpiAlarm"))
              .build();
        }
      }
    }
    return getSetKpiAlarmMethod;
  }

  private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
      monitoring.Monitoring.AlarmList> getGetAlarmsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetAlarms",
      requestType = context.ContextOuterClass.Empty.class,
      responseType = monitoring.Monitoring.AlarmList.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
      monitoring.Monitoring.AlarmList> getGetAlarmsMethod() {
    io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, monitoring.Monitoring.AlarmList> getGetAlarmsMethod;
    if ((getGetAlarmsMethod = MonitoringServiceGrpc.getGetAlarmsMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getGetAlarmsMethod = MonitoringServiceGrpc.getGetAlarmsMethod) == null) {
          MonitoringServiceGrpc.getGetAlarmsMethod = getGetAlarmsMethod =
              io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, monitoring.Monitoring.AlarmList>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAlarms"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  context.ContextOuterClass.Empty.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.AlarmList.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("GetAlarms"))
              .build();
        }
      }
    }
    return getGetAlarmsMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmID,
      monitoring.Monitoring.AlarmDescriptor> getGetAlarmDescriptorMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetAlarmDescriptor",
      requestType = monitoring.Monitoring.AlarmID.class,
      responseType = monitoring.Monitoring.AlarmDescriptor.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmID,
      monitoring.Monitoring.AlarmDescriptor> getGetAlarmDescriptorMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmID, monitoring.Monitoring.AlarmDescriptor> getGetAlarmDescriptorMethod;
    if ((getGetAlarmDescriptorMethod = MonitoringServiceGrpc.getGetAlarmDescriptorMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getGetAlarmDescriptorMethod = MonitoringServiceGrpc.getGetAlarmDescriptorMethod) == null) {
          MonitoringServiceGrpc.getGetAlarmDescriptorMethod = getGetAlarmDescriptorMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.AlarmID, monitoring.Monitoring.AlarmDescriptor>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAlarmDescriptor"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.AlarmID.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.AlarmDescriptor.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("GetAlarmDescriptor"))
              .build();
        }
      }
    }
    return getGetAlarmDescriptorMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmSubscription,
      monitoring.Monitoring.AlarmResponse> getGetAlarmResponseStreamMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetAlarmResponseStream",
      requestType = monitoring.Monitoring.AlarmSubscription.class,
      responseType = monitoring.Monitoring.AlarmResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmSubscription,
      monitoring.Monitoring.AlarmResponse> getGetAlarmResponseStreamMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmSubscription, monitoring.Monitoring.AlarmResponse> getGetAlarmResponseStreamMethod;
    if ((getGetAlarmResponseStreamMethod = MonitoringServiceGrpc.getGetAlarmResponseStreamMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getGetAlarmResponseStreamMethod = MonitoringServiceGrpc.getGetAlarmResponseStreamMethod) == null) {
          MonitoringServiceGrpc.getGetAlarmResponseStreamMethod = getGetAlarmResponseStreamMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.AlarmSubscription, monitoring.Monitoring.AlarmResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAlarmResponseStream"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.AlarmSubscription.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.AlarmResponse.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("GetAlarmResponseStream"))
              .build();
        }
      }
    }
    return getGetAlarmResponseStreamMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmID,
      context.ContextOuterClass.Empty> getDeleteAlarmMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteAlarm",
      requestType = monitoring.Monitoring.AlarmID.class,
      responseType = context.ContextOuterClass.Empty.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmID,
      context.ContextOuterClass.Empty> getDeleteAlarmMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmID, context.ContextOuterClass.Empty> getDeleteAlarmMethod;
    if ((getDeleteAlarmMethod = MonitoringServiceGrpc.getDeleteAlarmMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getDeleteAlarmMethod = MonitoringServiceGrpc.getDeleteAlarmMethod) == null) {
          MonitoringServiceGrpc.getDeleteAlarmMethod = getDeleteAlarmMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.AlarmID, context.ContextOuterClass.Empty>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteAlarm"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.AlarmID.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  context.ContextOuterClass.Empty.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("DeleteAlarm"))
              .build();
        }
      }
    }
    return getDeleteAlarmMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId,
      monitoring.Monitoring.Kpi> getGetStreamKpiMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetStreamKpi",
      requestType = monitoring.Monitoring.KpiId.class,
      responseType = monitoring.Monitoring.Kpi.class,
      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId,
      monitoring.Monitoring.Kpi> getGetStreamKpiMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId, monitoring.Monitoring.Kpi> getGetStreamKpiMethod;
    if ((getGetStreamKpiMethod = MonitoringServiceGrpc.getGetStreamKpiMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getGetStreamKpiMethod = MonitoringServiceGrpc.getGetStreamKpiMethod) == null) {
          MonitoringServiceGrpc.getGetStreamKpiMethod = getGetStreamKpiMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.KpiId, monitoring.Monitoring.Kpi>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetStreamKpi"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.KpiId.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.Kpi.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("GetStreamKpi"))
              .build();
        }
      }
    }
    return getGetStreamKpiMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId,
      monitoring.Monitoring.Kpi> getGetInstantKpiMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetInstantKpi",
      requestType = monitoring.Monitoring.KpiId.class,
      responseType = monitoring.Monitoring.Kpi.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId,
      monitoring.Monitoring.Kpi> getGetInstantKpiMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.KpiId, monitoring.Monitoring.Kpi> getGetInstantKpiMethod;
    if ((getGetInstantKpiMethod = MonitoringServiceGrpc.getGetInstantKpiMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getGetInstantKpiMethod = MonitoringServiceGrpc.getGetInstantKpiMethod) == null) {
          MonitoringServiceGrpc.getGetInstantKpiMethod = getGetInstantKpiMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.KpiId, monitoring.Monitoring.Kpi>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetInstantKpi"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.KpiId.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.Kpi.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("GetInstantKpi"))
              .build();
        }
      }
    }
    return getGetInstantKpiMethod;
  }

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

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

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

  /**
   */
  public static abstract class MonitoringServiceImplBase implements io.grpc.BindableService {

    /**
     */
    public void setKpi(monitoring.Monitoring.KpiDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiId> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetKpiMethod(), responseObserver);
    }

    /**
     */
    public void deleteKpi(monitoring.Monitoring.KpiId request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteKpiMethod(), responseObserver);
    }

    /**
     */
    public void getKpiDescriptor(monitoring.Monitoring.KpiId request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiDescriptor> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetKpiDescriptorMethod(), responseObserver);
    }

    /**
     */
    public void getKpiDescriptorList(context.ContextOuterClass.Empty request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiDescriptorList> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetKpiDescriptorListMethod(), responseObserver);
    }

    /**
     */
    public void includeKpi(monitoring.Monitoring.Kpi request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getIncludeKpiMethod(), responseObserver);
    }

    /**
     */
    public void monitorKpi(monitoring.Monitoring.MonitorKpiRequest request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getMonitorKpiMethod(), responseObserver);
    }

    /**
     */
    public void queryKpiData(monitoring.Monitoring.KpiQuery request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.RawKpiTable> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getQueryKpiDataMethod(), responseObserver);
    }

    /**
     */
    public void setKpiSubscription(monitoring.Monitoring.SubsDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.SubsResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetKpiSubscriptionMethod(), responseObserver);
    }

    /**
     */
    public void getSubsDescriptor(monitoring.Monitoring.SubscriptionID request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.SubsDescriptor> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetSubsDescriptorMethod(), responseObserver);
    }

    /**
     */
    public void getSubscriptions(context.ContextOuterClass.Empty request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.SubsList> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetSubscriptionsMethod(), responseObserver);
    }

    /**
     */
    public void deleteSubscription(monitoring.Monitoring.SubscriptionID request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteSubscriptionMethod(), responseObserver);
    }

    /**
     */
    public void setKpiAlarm(monitoring.Monitoring.AlarmDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmID> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetKpiAlarmMethod(), responseObserver);
    }

    /**
     */
    public void getAlarms(context.ContextOuterClass.Empty request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmList> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetAlarmsMethod(), responseObserver);
    }

    /**
     */
    public void getAlarmDescriptor(monitoring.Monitoring.AlarmID request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmDescriptor> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetAlarmDescriptorMethod(), responseObserver);
    }

    /**
     */
    public void getAlarmResponseStream(monitoring.Monitoring.AlarmSubscription request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetAlarmResponseStreamMethod(), responseObserver);
    }

    /**
     */
    public void deleteAlarm(monitoring.Monitoring.AlarmID request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteAlarmMethod(), responseObserver);
    }

    /**
     */
    public void getStreamKpi(monitoring.Monitoring.KpiId request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.Kpi> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetStreamKpiMethod(), responseObserver);
    }

    /**
     */
    public void getInstantKpi(monitoring.Monitoring.KpiId request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.Kpi> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetInstantKpiMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getSetKpiMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.KpiDescriptor,
                monitoring.Monitoring.KpiId>(
                  this, METHODID_SET_KPI)))
          .addMethod(
            getDeleteKpiMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.KpiId,
                context.ContextOuterClass.Empty>(
                  this, METHODID_DELETE_KPI)))
          .addMethod(
            getGetKpiDescriptorMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.KpiId,
                monitoring.Monitoring.KpiDescriptor>(
                  this, METHODID_GET_KPI_DESCRIPTOR)))
          .addMethod(
            getGetKpiDescriptorListMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                context.ContextOuterClass.Empty,
                monitoring.Monitoring.KpiDescriptorList>(
                  this, METHODID_GET_KPI_DESCRIPTOR_LIST)))
          .addMethod(
            getIncludeKpiMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.Kpi,
                context.ContextOuterClass.Empty>(
                  this, METHODID_INCLUDE_KPI)))
          .addMethod(
            getMonitorKpiMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.MonitorKpiRequest,
                context.ContextOuterClass.Empty>(
                  this, METHODID_MONITOR_KPI)))
          .addMethod(
            getQueryKpiDataMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.KpiQuery,
                monitoring.Monitoring.RawKpiTable>(
                  this, METHODID_QUERY_KPI_DATA)))
          .addMethod(
            getSetKpiSubscriptionMethod(),
            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
              new MethodHandlers<
                monitoring.Monitoring.SubsDescriptor,
                monitoring.Monitoring.SubsResponse>(
                  this, METHODID_SET_KPI_SUBSCRIPTION)))
          .addMethod(
            getGetSubsDescriptorMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.SubscriptionID,
                monitoring.Monitoring.SubsDescriptor>(
                  this, METHODID_GET_SUBS_DESCRIPTOR)))
          .addMethod(
            getGetSubscriptionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                context.ContextOuterClass.Empty,
                monitoring.Monitoring.SubsList>(
                  this, METHODID_GET_SUBSCRIPTIONS)))
          .addMethod(
            getDeleteSubscriptionMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.SubscriptionID,
                context.ContextOuterClass.Empty>(
                  this, METHODID_DELETE_SUBSCRIPTION)))
          .addMethod(
            getSetKpiAlarmMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.AlarmDescriptor,
                monitoring.Monitoring.AlarmID>(
                  this, METHODID_SET_KPI_ALARM)))
          .addMethod(
            getGetAlarmsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                context.ContextOuterClass.Empty,
                monitoring.Monitoring.AlarmList>(
                  this, METHODID_GET_ALARMS)))
          .addMethod(
            getGetAlarmDescriptorMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.AlarmID,
                monitoring.Monitoring.AlarmDescriptor>(
                  this, METHODID_GET_ALARM_DESCRIPTOR)))
          .addMethod(
            getGetAlarmResponseStreamMethod(),
            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
              new MethodHandlers<
                monitoring.Monitoring.AlarmSubscription,
                monitoring.Monitoring.AlarmResponse>(
                  this, METHODID_GET_ALARM_RESPONSE_STREAM)))
          .addMethod(
            getDeleteAlarmMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.AlarmID,
                context.ContextOuterClass.Empty>(
                  this, METHODID_DELETE_ALARM)))
          .addMethod(
            getGetStreamKpiMethod(),
            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
              new MethodHandlers<
                monitoring.Monitoring.KpiId,
                monitoring.Monitoring.Kpi>(
                  this, METHODID_GET_STREAM_KPI)))
          .addMethod(
            getGetInstantKpiMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.KpiId,
                monitoring.Monitoring.Kpi>(
                  this, METHODID_GET_INSTANT_KPI)))
          .build();
    }
  }

  /**
   */
  public static final class MonitoringServiceStub extends io.grpc.stub.AbstractAsyncStub<MonitoringServiceStub> {
    private MonitoringServiceStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     */
    public void setKpi(monitoring.Monitoring.KpiDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiId> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetKpiMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void deleteKpi(monitoring.Monitoring.KpiId request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteKpiMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getKpiDescriptor(monitoring.Monitoring.KpiId request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiDescriptor> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetKpiDescriptorMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getKpiDescriptorList(context.ContextOuterClass.Empty request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiDescriptorList> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetKpiDescriptorListMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void includeKpi(monitoring.Monitoring.Kpi request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getIncludeKpiMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void monitorKpi(monitoring.Monitoring.MonitorKpiRequest request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getMonitorKpiMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void queryKpiData(monitoring.Monitoring.KpiQuery request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.RawKpiTable> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getQueryKpiDataMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setKpiSubscription(monitoring.Monitoring.SubsDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.SubsResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
          getChannel().newCall(getSetKpiSubscriptionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getSubsDescriptor(monitoring.Monitoring.SubscriptionID request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.SubsDescriptor> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetSubsDescriptorMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getSubscriptions(context.ContextOuterClass.Empty request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.SubsList> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetSubscriptionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void deleteSubscription(monitoring.Monitoring.SubscriptionID request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteSubscriptionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setKpiAlarm(monitoring.Monitoring.AlarmDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmID> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetKpiAlarmMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getAlarms(context.ContextOuterClass.Empty request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmList> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetAlarmsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getAlarmDescriptor(monitoring.Monitoring.AlarmID request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmDescriptor> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetAlarmDescriptorMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getAlarmResponseStream(monitoring.Monitoring.AlarmSubscription request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
          getChannel().newCall(getGetAlarmResponseStreamMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void deleteAlarm(monitoring.Monitoring.AlarmID request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteAlarmMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getStreamKpi(monitoring.Monitoring.KpiId request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.Kpi> responseObserver) {
      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
          getChannel().newCall(getGetStreamKpiMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getInstantKpi(monitoring.Monitoring.KpiId request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.Kpi> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetInstantKpiMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   */
  public static final class MonitoringServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<MonitoringServiceBlockingStub> {
    private MonitoringServiceBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     */
    public monitoring.Monitoring.KpiId setKpi(monitoring.Monitoring.KpiDescriptor request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetKpiMethod(), getCallOptions(), request);
    }

    /**
     */
    public context.ContextOuterClass.Empty deleteKpi(monitoring.Monitoring.KpiId request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteKpiMethod(), getCallOptions(), request);
    }

    /**
     */
    public monitoring.Monitoring.KpiDescriptor getKpiDescriptor(monitoring.Monitoring.KpiId request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetKpiDescriptorMethod(), getCallOptions(), request);
    }

    /**
     */
    public monitoring.Monitoring.KpiDescriptorList getKpiDescriptorList(context.ContextOuterClass.Empty request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetKpiDescriptorListMethod(), getCallOptions(), request);
    }

    /**
     */
    public context.ContextOuterClass.Empty includeKpi(monitoring.Monitoring.Kpi request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getIncludeKpiMethod(), getCallOptions(), request);
    }

    /**
     */
    public context.ContextOuterClass.Empty monitorKpi(monitoring.Monitoring.MonitorKpiRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getMonitorKpiMethod(), getCallOptions(), request);
    }

    /**
     */
    public monitoring.Monitoring.RawKpiTable queryKpiData(monitoring.Monitoring.KpiQuery request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getQueryKpiDataMethod(), getCallOptions(), request);
    }

    /**
     */
    public java.util.Iterator<monitoring.Monitoring.SubsResponse> setKpiSubscription(
        monitoring.Monitoring.SubsDescriptor request) {
      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
          getChannel(), getSetKpiSubscriptionMethod(), getCallOptions(), request);
    }

    /**
     */
    public monitoring.Monitoring.SubsDescriptor getSubsDescriptor(monitoring.Monitoring.SubscriptionID request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetSubsDescriptorMethod(), getCallOptions(), request);
    }

    /**
     */
    public monitoring.Monitoring.SubsList getSubscriptions(context.ContextOuterClass.Empty request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetSubscriptionsMethod(), getCallOptions(), request);
    }

    /**
     */
    public context.ContextOuterClass.Empty deleteSubscription(monitoring.Monitoring.SubscriptionID request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteSubscriptionMethod(), getCallOptions(), request);
    }

    /**
     */
    public monitoring.Monitoring.AlarmID setKpiAlarm(monitoring.Monitoring.AlarmDescriptor request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetKpiAlarmMethod(), getCallOptions(), request);
    }

    /**
     */
    public monitoring.Monitoring.AlarmList getAlarms(context.ContextOuterClass.Empty request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetAlarmsMethod(), getCallOptions(), request);
    }

    /**
     */
    public monitoring.Monitoring.AlarmDescriptor getAlarmDescriptor(monitoring.Monitoring.AlarmID request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetAlarmDescriptorMethod(), getCallOptions(), request);
    }

    /**
     */
    public java.util.Iterator<monitoring.Monitoring.AlarmResponse> getAlarmResponseStream(
        monitoring.Monitoring.AlarmSubscription request) {
      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
          getChannel(), getGetAlarmResponseStreamMethod(), getCallOptions(), request);
    }

    /**
     */
    public context.ContextOuterClass.Empty deleteAlarm(monitoring.Monitoring.AlarmID request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteAlarmMethod(), getCallOptions(), request);
    }

    /**
     */
    public java.util.Iterator<monitoring.Monitoring.Kpi> getStreamKpi(
        monitoring.Monitoring.KpiId request) {
      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
          getChannel(), getGetStreamKpiMethod(), getCallOptions(), request);
    }

    /**
     */
    public monitoring.Monitoring.Kpi getInstantKpi(monitoring.Monitoring.KpiId request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetInstantKpiMethod(), getCallOptions(), request);
    }
  }

  /**
   */
  public static final class MonitoringServiceFutureStub extends io.grpc.stub.AbstractFutureStub<MonitoringServiceFutureStub> {
    private MonitoringServiceFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

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

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.KpiId> setKpi(
        monitoring.Monitoring.KpiDescriptor request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetKpiMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<context.ContextOuterClass.Empty> deleteKpi(
        monitoring.Monitoring.KpiId request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteKpiMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.KpiDescriptor> getKpiDescriptor(
        monitoring.Monitoring.KpiId request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetKpiDescriptorMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.KpiDescriptorList> getKpiDescriptorList(
        context.ContextOuterClass.Empty request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetKpiDescriptorListMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<context.ContextOuterClass.Empty> includeKpi(
        monitoring.Monitoring.Kpi request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getIncludeKpiMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<context.ContextOuterClass.Empty> monitorKpi(
        monitoring.Monitoring.MonitorKpiRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getMonitorKpiMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.RawKpiTable> queryKpiData(
        monitoring.Monitoring.KpiQuery request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getQueryKpiDataMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.SubsDescriptor> getSubsDescriptor(
        monitoring.Monitoring.SubscriptionID request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetSubsDescriptorMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.SubsList> getSubscriptions(
        context.ContextOuterClass.Empty request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetSubscriptionsMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<context.ContextOuterClass.Empty> deleteSubscription(
        monitoring.Monitoring.SubscriptionID request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteSubscriptionMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.AlarmID> setKpiAlarm(
        monitoring.Monitoring.AlarmDescriptor request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetKpiAlarmMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.AlarmList> getAlarms(
        context.ContextOuterClass.Empty request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetAlarmsMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.AlarmDescriptor> getAlarmDescriptor(
        monitoring.Monitoring.AlarmID request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetAlarmDescriptorMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<context.ContextOuterClass.Empty> deleteAlarm(
        monitoring.Monitoring.AlarmID request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteAlarmMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.Kpi> getInstantKpi(
        monitoring.Monitoring.KpiId request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetInstantKpiMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_SET_KPI = 0;
  private static final int METHODID_DELETE_KPI = 1;
  private static final int METHODID_GET_KPI_DESCRIPTOR = 2;
  private static final int METHODID_GET_KPI_DESCRIPTOR_LIST = 3;
  private static final int METHODID_INCLUDE_KPI = 4;
  private static final int METHODID_MONITOR_KPI = 5;
  private static final int METHODID_QUERY_KPI_DATA = 6;
  private static final int METHODID_SET_KPI_SUBSCRIPTION = 7;
  private static final int METHODID_GET_SUBS_DESCRIPTOR = 8;
  private static final int METHODID_GET_SUBSCRIPTIONS = 9;
  private static final int METHODID_DELETE_SUBSCRIPTION = 10;
  private static final int METHODID_SET_KPI_ALARM = 11;
  private static final int METHODID_GET_ALARMS = 12;
  private static final int METHODID_GET_ALARM_DESCRIPTOR = 13;
  private static final int METHODID_GET_ALARM_RESPONSE_STREAM = 14;
  private static final int METHODID_DELETE_ALARM = 15;
  private static final int METHODID_GET_STREAM_KPI = 16;
  private static final int METHODID_GET_INSTANT_KPI = 17;

  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 MonitoringServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(MonitoringServiceImplBase 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_SET_KPI:
          serviceImpl.setKpi((monitoring.Monitoring.KpiDescriptor) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiId>) responseObserver);
          break;
        case METHODID_DELETE_KPI:
          serviceImpl.deleteKpi((monitoring.Monitoring.KpiId) request,
              (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver);
          break;
        case METHODID_GET_KPI_DESCRIPTOR:
          serviceImpl.getKpiDescriptor((monitoring.Monitoring.KpiId) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiDescriptor>) responseObserver);
          break;
        case METHODID_GET_KPI_DESCRIPTOR_LIST:
          serviceImpl.getKpiDescriptorList((context.ContextOuterClass.Empty) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiDescriptorList>) responseObserver);
          break;
        case METHODID_INCLUDE_KPI:
          serviceImpl.includeKpi((monitoring.Monitoring.Kpi) request,
              (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver);
          break;
        case METHODID_MONITOR_KPI:
          serviceImpl.monitorKpi((monitoring.Monitoring.MonitorKpiRequest) request,
              (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver);
          break;
        case METHODID_QUERY_KPI_DATA:
          serviceImpl.queryKpiData((monitoring.Monitoring.KpiQuery) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.RawKpiTable>) responseObserver);
          break;
        case METHODID_SET_KPI_SUBSCRIPTION:
          serviceImpl.setKpiSubscription((monitoring.Monitoring.SubsDescriptor) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.SubsResponse>) responseObserver);
          break;
        case METHODID_GET_SUBS_DESCRIPTOR:
          serviceImpl.getSubsDescriptor((monitoring.Monitoring.SubscriptionID) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.SubsDescriptor>) responseObserver);
          break;
        case METHODID_GET_SUBSCRIPTIONS:
          serviceImpl.getSubscriptions((context.ContextOuterClass.Empty) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.SubsList>) responseObserver);
          break;
        case METHODID_DELETE_SUBSCRIPTION:
          serviceImpl.deleteSubscription((monitoring.Monitoring.SubscriptionID) request,
              (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver);
          break;
        case METHODID_SET_KPI_ALARM:
          serviceImpl.setKpiAlarm((monitoring.Monitoring.AlarmDescriptor) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmID>) responseObserver);
          break;
        case METHODID_GET_ALARMS:
          serviceImpl.getAlarms((context.ContextOuterClass.Empty) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmList>) responseObserver);
          break;
        case METHODID_GET_ALARM_DESCRIPTOR:
          serviceImpl.getAlarmDescriptor((monitoring.Monitoring.AlarmID) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmDescriptor>) responseObserver);
          break;
        case METHODID_GET_ALARM_RESPONSE_STREAM:
          serviceImpl.getAlarmResponseStream((monitoring.Monitoring.AlarmSubscription) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmResponse>) responseObserver);
          break;
        case METHODID_DELETE_ALARM:
          serviceImpl.deleteAlarm((monitoring.Monitoring.AlarmID) request,
              (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver);
          break;
        case METHODID_GET_STREAM_KPI:
          serviceImpl.getStreamKpi((monitoring.Monitoring.KpiId) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.Kpi>) responseObserver);
          break;
        case METHODID_GET_INSTANT_KPI:
          serviceImpl.getInstantKpi((monitoring.Monitoring.KpiId) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.Kpi>) 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 MonitoringServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    MonitoringServiceBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return monitoring.Monitoring.getDescriptor();
    }

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

  private static final class MonitoringServiceFileDescriptorSupplier
      extends MonitoringServiceBaseDescriptorSupplier {
    MonitoringServiceFileDescriptorSupplier() {}
  }

  private static final class MonitoringServiceMethodDescriptorSupplier
      extends MonitoringServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    MonitoringServiceMethodDescriptorSupplier(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 (MonitoringServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new MonitoringServiceFileDescriptorSupplier())
              .addMethod(getSetKpiMethod())
              .addMethod(getDeleteKpiMethod())
              .addMethod(getGetKpiDescriptorMethod())
              .addMethod(getGetKpiDescriptorListMethod())
              .addMethod(getIncludeKpiMethod())
              .addMethod(getMonitorKpiMethod())
              .addMethod(getQueryKpiDataMethod())
              .addMethod(getSetKpiSubscriptionMethod())
              .addMethod(getGetSubsDescriptorMethod())
              .addMethod(getGetSubscriptionsMethod())
              .addMethod(getDeleteSubscriptionMethod())
              .addMethod(getSetKpiAlarmMethod())
              .addMethod(getGetAlarmsMethod())
              .addMethod(getGetAlarmDescriptorMethod())
              .addMethod(getGetAlarmResponseStreamMethod())
              .addMethod(getDeleteAlarmMethod())
              .addMethod(getGetStreamKpiMethod())
              .addMethod(getGetInstantKpiMethod())
              .build();
        }
      }
    }
    return result;
  }
}
