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> getCreateKpiMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "CreateKpi",
      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> getCreateKpiMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.KpiDescriptor, monitoring.Monitoring.KpiId> getCreateKpiMethod;
    if ((getCreateKpiMethod = MonitoringServiceGrpc.getCreateKpiMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getCreateKpiMethod = MonitoringServiceGrpc.getCreateKpiMethod) == null) {
          MonitoringServiceGrpc.getCreateKpiMethod = getCreateKpiMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.KpiDescriptor, monitoring.Monitoring.KpiId>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CreateKpi"))
              .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("CreateKpi"))
              .build();
        }
      }
    }
    return getCreateKpiMethod;
  }

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

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

  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<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.BundleKpiDescriptor,
      monitoring.Monitoring.KpiId> getCreateBundleKpiMethod;

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

  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<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.KpiList> getQueryKpiDataMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "QueryKpiData",
      requestType = monitoring.Monitoring.KpiQuery.class,
      responseType = monitoring.Monitoring.KpiList.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.KpiQuery,
      monitoring.Monitoring.KpiList> getQueryKpiDataMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.KpiQuery, monitoring.Monitoring.KpiList> 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.KpiList>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.KpiList.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("QueryKpiData"))
              .build();
        }
      }
    }
    return getQueryKpiDataMethod;
  }

  private static volatile io.grpc.MethodDescriptor<monitoring.Monitoring.SubsDescriptor,
      monitoring.Monitoring.KpiList> getSubscribeKpiMethod;

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

  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.SubsIDList> getGetSubscriptionsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetSubscriptions",
      requestType = context.ContextOuterClass.Empty.class,
      responseType = monitoring.Monitoring.SubsIDList.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
      monitoring.Monitoring.SubsIDList> getGetSubscriptionsMethod() {
    io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, monitoring.Monitoring.SubsIDList> 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.SubsIDList>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.SubsIDList.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("GetSubscriptions"))
              .build();
        }
      }
    }
    return getGetSubscriptionsMethod;
  }

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

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

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

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "CreateKpiAlarm",
      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> getCreateKpiAlarmMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmDescriptor, monitoring.Monitoring.AlarmID> getCreateKpiAlarmMethod;
    if ((getCreateKpiAlarmMethod = MonitoringServiceGrpc.getCreateKpiAlarmMethod) == null) {
      synchronized (MonitoringServiceGrpc.class) {
        if ((getCreateKpiAlarmMethod = MonitoringServiceGrpc.getCreateKpiAlarmMethod) == null) {
          MonitoringServiceGrpc.getCreateKpiAlarmMethod = getCreateKpiAlarmMethod =
              io.grpc.MethodDescriptor.<monitoring.Monitoring.AlarmDescriptor, monitoring.Monitoring.AlarmID>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CreateKpiAlarm"))
              .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("CreateKpiAlarm"))
              .build();
        }
      }
    }
    return getCreateKpiAlarmMethod;
  }

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

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

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

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetAlarms",
      requestType = context.ContextOuterClass.Empty.class,
      responseType = monitoring.Monitoring.AlarmIDList.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty,
      monitoring.Monitoring.AlarmIDList> getGetAlarmsMethod() {
    io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, monitoring.Monitoring.AlarmIDList> 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.AlarmIDList>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.AlarmIDList.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.AlarmID,
      monitoring.Monitoring.AlarmResponse> getGetAlarmResponseStreamMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetAlarmResponseStream",
      requestType = monitoring.Monitoring.AlarmID.class,
      responseType = monitoring.Monitoring.AlarmResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
  public static io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmID,
      monitoring.Monitoring.AlarmResponse> getGetAlarmResponseStreamMethod() {
    io.grpc.MethodDescriptor<monitoring.Monitoring.AlarmID, 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.AlarmID, 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.AlarmID.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  monitoring.Monitoring.AlarmResponse.getDefaultInstance()))
              .setSchemaDescriptor(new MonitoringServiceMethodDescriptorSupplier("GetAlarmResponseStream"))
              .build();
        }
      }
    }
    return getGetAlarmResponseStreamMethod;
  }

  /**
   * 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 createKpi(monitoring.Monitoring.KpiDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiId> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateKpiMethod(), responseObserver);
    }

    /**
     */
    public void editKpiDescriptor(monitoring.Monitoring.EditedKpiDescriptor request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getEditKpiDescriptorMethod(), 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 getKpiDescriptorList(context.ContextOuterClass.Empty request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiDescriptorList> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetKpiDescriptorListMethod(), responseObserver);
    }

    /**
     */
    public void createBundleKpi(monitoring.Monitoring.BundleKpiDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiId> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateBundleKpiMethod(), 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 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.KpiList> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getQueryKpiDataMethod(), responseObserver);
    }

    /**
     */
    public void subscribeKpi(monitoring.Monitoring.SubsDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiList> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSubscribeKpiMethod(), 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.SubsIDList> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetSubscriptionsMethod(), responseObserver);
    }

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

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

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

    /**
     */
    public void getAlarms(context.ContextOuterClass.Empty request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmIDList> 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.AlarmID request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetAlarmResponseStreamMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getCreateKpiMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.KpiDescriptor,
                monitoring.Monitoring.KpiId>(
                  this, METHODID_CREATE_KPI)))
          .addMethod(
            getEditKpiDescriptorMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.EditedKpiDescriptor,
                context.ContextOuterClass.Empty>(
                  this, METHODID_EDIT_KPI_DESCRIPTOR)))
          .addMethod(
            getDeleteKpiMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.KpiId,
                context.ContextOuterClass.Empty>(
                  this, METHODID_DELETE_KPI)))
          .addMethod(
            getGetKpiDescriptorListMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                context.ContextOuterClass.Empty,
                monitoring.Monitoring.KpiDescriptorList>(
                  this, METHODID_GET_KPI_DESCRIPTOR_LIST)))
          .addMethod(
            getCreateBundleKpiMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.BundleKpiDescriptor,
                monitoring.Monitoring.KpiId>(
                  this, METHODID_CREATE_BUNDLE_KPI)))
          .addMethod(
            getGetKpiDescriptorMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.KpiId,
                monitoring.Monitoring.KpiDescriptor>(
                  this, METHODID_GET_KPI_DESCRIPTOR)))
          .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.KpiList>(
                  this, METHODID_QUERY_KPI_DATA)))
          .addMethod(
            getSubscribeKpiMethod(),
            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
              new MethodHandlers<
                monitoring.Monitoring.SubsDescriptor,
                monitoring.Monitoring.KpiList>(
                  this, METHODID_SUBSCRIBE_KPI)))
          .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.SubsIDList>(
                  this, METHODID_GET_SUBSCRIPTIONS)))
          .addMethod(
            getEditKpiSubscriptionMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.SubsDescriptor,
                context.ContextOuterClass.Empty>(
                  this, METHODID_EDIT_KPI_SUBSCRIPTION)))
          .addMethod(
            getCreateKpiAlarmMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.AlarmDescriptor,
                monitoring.Monitoring.AlarmID>(
                  this, METHODID_CREATE_KPI_ALARM)))
          .addMethod(
            getEditKpiAlarmMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                monitoring.Monitoring.AlarmDescriptor,
                context.ContextOuterClass.Empty>(
                  this, METHODID_EDIT_KPI_ALARM)))
          .addMethod(
            getGetAlarmsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                context.ContextOuterClass.Empty,
                monitoring.Monitoring.AlarmIDList>(
                  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.AlarmID,
                monitoring.Monitoring.AlarmResponse>(
                  this, METHODID_GET_ALARM_RESPONSE_STREAM)))
          .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 createKpi(monitoring.Monitoring.KpiDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiId> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCreateKpiMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void editKpiDescriptor(monitoring.Monitoring.EditedKpiDescriptor request,
        io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getEditKpiDescriptorMethod(), 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 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 createBundleKpi(monitoring.Monitoring.BundleKpiDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiId> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCreateBundleKpiMethod(), 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 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.KpiList> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getQueryKpiDataMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void subscribeKpi(monitoring.Monitoring.SubsDescriptor request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiList> responseObserver) {
      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
          getChannel().newCall(getSubscribeKpiMethod(), 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.SubsIDList> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetSubscriptionsMethod(), getCallOptions()), request, responseObserver);
    }

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

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

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

    /**
     */
    public void getAlarms(context.ContextOuterClass.Empty request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmIDList> 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.AlarmID request,
        io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
          getChannel().newCall(getGetAlarmResponseStreamMethod(), 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 createKpi(monitoring.Monitoring.KpiDescriptor request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCreateKpiMethod(), getCallOptions(), request);
    }

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

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

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

    /**
     */
    public monitoring.Monitoring.KpiId createBundleKpi(monitoring.Monitoring.BundleKpiDescriptor request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCreateBundleKpiMethod(), getCallOptions(), request);
    }

    /**
     */
    public monitoring.Monitoring.KpiDescriptor getKpiDescriptor(monitoring.Monitoring.KpiId request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetKpiDescriptorMethod(), 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.KpiList queryKpiData(monitoring.Monitoring.KpiQuery request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getQueryKpiDataMethod(), getCallOptions(), request);
    }

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

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

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

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

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

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

    /**
     */
    public monitoring.Monitoring.AlarmIDList 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.AlarmID request) {
      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
          getChannel(), getGetAlarmResponseStreamMethod(), 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> createKpi(
        monitoring.Monitoring.KpiDescriptor request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCreateKpiMethod(), getCallOptions()), request);
    }

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

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.KpiId> createBundleKpi(
        monitoring.Monitoring.BundleKpiDescriptor request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCreateBundleKpiMethod(), 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<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.KpiList> 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.SubsIDList> 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> editKpiSubscription(
        monitoring.Monitoring.SubsDescriptor request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getEditKpiSubscriptionMethod(), getCallOptions()), request);
    }

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

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

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<monitoring.Monitoring.AlarmIDList> 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);
    }
  }

  private static final int METHODID_CREATE_KPI = 0;
  private static final int METHODID_EDIT_KPI_DESCRIPTOR = 1;
  private static final int METHODID_DELETE_KPI = 2;
  private static final int METHODID_GET_KPI_DESCRIPTOR_LIST = 3;
  private static final int METHODID_CREATE_BUNDLE_KPI = 4;
  private static final int METHODID_GET_KPI_DESCRIPTOR = 5;
  private static final int METHODID_INCLUDE_KPI = 6;
  private static final int METHODID_MONITOR_KPI = 7;
  private static final int METHODID_QUERY_KPI_DATA = 8;
  private static final int METHODID_SUBSCRIBE_KPI = 9;
  private static final int METHODID_GET_SUBS_DESCRIPTOR = 10;
  private static final int METHODID_GET_SUBSCRIPTIONS = 11;
  private static final int METHODID_EDIT_KPI_SUBSCRIPTION = 12;
  private static final int METHODID_CREATE_KPI_ALARM = 13;
  private static final int METHODID_EDIT_KPI_ALARM = 14;
  private static final int METHODID_GET_ALARMS = 15;
  private static final int METHODID_GET_ALARM_DESCRIPTOR = 16;
  private static final int METHODID_GET_ALARM_RESPONSE_STREAM = 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_CREATE_KPI:
          serviceImpl.createKpi((monitoring.Monitoring.KpiDescriptor) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiId>) responseObserver);
          break;
        case METHODID_EDIT_KPI_DESCRIPTOR:
          serviceImpl.editKpiDescriptor((monitoring.Monitoring.EditedKpiDescriptor) request,
              (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) 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_LIST:
          serviceImpl.getKpiDescriptorList((context.ContextOuterClass.Empty) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiDescriptorList>) responseObserver);
          break;
        case METHODID_CREATE_BUNDLE_KPI:
          serviceImpl.createBundleKpi((monitoring.Monitoring.BundleKpiDescriptor) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiId>) responseObserver);
          break;
        case METHODID_GET_KPI_DESCRIPTOR:
          serviceImpl.getKpiDescriptor((monitoring.Monitoring.KpiId) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiDescriptor>) 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.KpiList>) responseObserver);
          break;
        case METHODID_SUBSCRIBE_KPI:
          serviceImpl.subscribeKpi((monitoring.Monitoring.SubsDescriptor) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.KpiList>) 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.SubsIDList>) responseObserver);
          break;
        case METHODID_EDIT_KPI_SUBSCRIPTION:
          serviceImpl.editKpiSubscription((monitoring.Monitoring.SubsDescriptor) request,
              (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver);
          break;
        case METHODID_CREATE_KPI_ALARM:
          serviceImpl.createKpiAlarm((monitoring.Monitoring.AlarmDescriptor) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmID>) responseObserver);
          break;
        case METHODID_EDIT_KPI_ALARM:
          serviceImpl.editKpiAlarm((monitoring.Monitoring.AlarmDescriptor) request,
              (io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty>) responseObserver);
          break;
        case METHODID_GET_ALARMS:
          serviceImpl.getAlarms((context.ContextOuterClass.Empty) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmIDList>) 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.AlarmID) request,
              (io.grpc.stub.StreamObserver<monitoring.Monitoring.AlarmResponse>) 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(getCreateKpiMethod())
              .addMethod(getEditKpiDescriptorMethod())
              .addMethod(getDeleteKpiMethod())
              .addMethod(getGetKpiDescriptorListMethod())
              .addMethod(getCreateBundleKpiMethod())
              .addMethod(getGetKpiDescriptorMethod())
              .addMethod(getIncludeKpiMethod())
              .addMethod(getMonitorKpiMethod())
              .addMethod(getQueryKpiDataMethod())
              .addMethod(getSubscribeKpiMethod())
              .addMethod(getGetSubsDescriptorMethod())
              .addMethod(getGetSubscriptionsMethod())
              .addMethod(getEditKpiSubscriptionMethod())
              .addMethod(getCreateKpiAlarmMethod())
              .addMethod(getEditKpiAlarmMethod())
              .addMethod(getGetAlarmsMethod())
              .addMethod(getGetAlarmDescriptorMethod())
              .addMethod(getGetAlarmResponseStreamMethod())
              .build();
        }
      }
    }
    return result;
  }
}
