com.clarifai.grpc.api.V2Grpc Maven / Gradle / Ivy

Go to download
package com.clarifai.grpc.api;

import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
import static io.grpc.stub.ClientCalls.blockingUnaryCall;
import static io.grpc.stub.ClientCalls.futureUnaryCall;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.27.2)",
    comments = "Source: proto/clarifai/api/service.proto")
public final class V2Grpc {

  private V2Grpc() {}

  public static final String SERVICE_NAME = "clarifai.api.V2";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor getListConceptRelationsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListConceptRelations",
      requestType = com.clarifai.grpc.api.ListConceptRelationsRequest.class,
      responseType = com.clarifai.grpc.api.MultiConceptRelationResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListConceptRelationsMethod() {
    io.grpc.MethodDescriptor getListConceptRelationsMethod;
    if ((getListConceptRelationsMethod = V2Grpc.getListConceptRelationsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListConceptRelationsMethod = V2Grpc.getListConceptRelationsMethod) == null) {
          V2Grpc.getListConceptRelationsMethod = getListConceptRelationsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListConceptRelations"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListConceptRelationsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiConceptRelationResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListConceptRelations"))
              .build();
        }
      }
    }
    return getListConceptRelationsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostConceptRelationsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostConceptRelations",
      requestType = com.clarifai.grpc.api.PostConceptRelationsRequest.class,
      responseType = com.clarifai.grpc.api.MultiConceptRelationResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostConceptRelationsMethod() {
    io.grpc.MethodDescriptor getPostConceptRelationsMethod;
    if ((getPostConceptRelationsMethod = V2Grpc.getPostConceptRelationsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostConceptRelationsMethod = V2Grpc.getPostConceptRelationsMethod) == null) {
          V2Grpc.getPostConceptRelationsMethod = getPostConceptRelationsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostConceptRelations"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostConceptRelationsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiConceptRelationResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostConceptRelations"))
              .build();
        }
      }
    }
    return getPostConceptRelationsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteConceptRelationsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteConceptRelations",
      requestType = com.clarifai.grpc.api.DeleteConceptRelationsRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteConceptRelationsMethod() {
    io.grpc.MethodDescriptor getDeleteConceptRelationsMethod;
    if ((getDeleteConceptRelationsMethod = V2Grpc.getDeleteConceptRelationsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteConceptRelationsMethod = V2Grpc.getDeleteConceptRelationsMethod) == null) {
          V2Grpc.getDeleteConceptRelationsMethod = getDeleteConceptRelationsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteConceptRelations"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteConceptRelationsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteConceptRelations"))
              .build();
        }
      }
    }
    return getDeleteConceptRelationsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetConceptCountsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetConceptCounts",
      requestType = com.clarifai.grpc.api.GetConceptCountsRequest.class,
      responseType = com.clarifai.grpc.api.MultiConceptCountResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetConceptCountsMethod() {
    io.grpc.MethodDescriptor getGetConceptCountsMethod;
    if ((getGetConceptCountsMethod = V2Grpc.getGetConceptCountsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetConceptCountsMethod = V2Grpc.getGetConceptCountsMethod) == null) {
          V2Grpc.getGetConceptCountsMethod = getGetConceptCountsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetConceptCounts"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetConceptCountsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiConceptCountResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetConceptCounts"))
              .build();
        }
      }
    }
    return getGetConceptCountsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetConceptMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetConcept",
      requestType = com.clarifai.grpc.api.GetConceptRequest.class,
      responseType = com.clarifai.grpc.api.SingleConceptResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetConceptMethod() {
    io.grpc.MethodDescriptor getGetConceptMethod;
    if ((getGetConceptMethod = V2Grpc.getGetConceptMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetConceptMethod = V2Grpc.getGetConceptMethod) == null) {
          V2Grpc.getGetConceptMethod = getGetConceptMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetConcept"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetConceptRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleConceptResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetConcept"))
              .build();
        }
      }
    }
    return getGetConceptMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListConceptsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListConcepts",
      requestType = com.clarifai.grpc.api.ListConceptsRequest.class,
      responseType = com.clarifai.grpc.api.MultiConceptResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListConceptsMethod() {
    io.grpc.MethodDescriptor getListConceptsMethod;
    if ((getListConceptsMethod = V2Grpc.getListConceptsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListConceptsMethod = V2Grpc.getListConceptsMethod) == null) {
          V2Grpc.getListConceptsMethod = getListConceptsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListConcepts"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListConceptsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiConceptResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListConcepts"))
              .build();
        }
      }
    }
    return getListConceptsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostConceptsSearchesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostConceptsSearches",
      requestType = com.clarifai.grpc.api.PostConceptsSearchesRequest.class,
      responseType = com.clarifai.grpc.api.MultiConceptResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostConceptsSearchesMethod() {
    io.grpc.MethodDescriptor getPostConceptsSearchesMethod;
    if ((getPostConceptsSearchesMethod = V2Grpc.getPostConceptsSearchesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostConceptsSearchesMethod = V2Grpc.getPostConceptsSearchesMethod) == null) {
          V2Grpc.getPostConceptsSearchesMethod = getPostConceptsSearchesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostConceptsSearches"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostConceptsSearchesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiConceptResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostConceptsSearches"))
              .build();
        }
      }
    }
    return getPostConceptsSearchesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostConceptsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostConcepts",
      requestType = com.clarifai.grpc.api.PostConceptsRequest.class,
      responseType = com.clarifai.grpc.api.MultiConceptResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostConceptsMethod() {
    io.grpc.MethodDescriptor getPostConceptsMethod;
    if ((getPostConceptsMethod = V2Grpc.getPostConceptsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostConceptsMethod = V2Grpc.getPostConceptsMethod) == null) {
          V2Grpc.getPostConceptsMethod = getPostConceptsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostConcepts"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostConceptsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiConceptResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostConcepts"))
              .build();
        }
      }
    }
    return getPostConceptsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchConceptsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchConcepts",
      requestType = com.clarifai.grpc.api.PatchConceptsRequest.class,
      responseType = com.clarifai.grpc.api.MultiConceptResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchConceptsMethod() {
    io.grpc.MethodDescriptor getPatchConceptsMethod;
    if ((getPatchConceptsMethod = V2Grpc.getPatchConceptsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchConceptsMethod = V2Grpc.getPatchConceptsMethod) == null) {
          V2Grpc.getPatchConceptsMethod = getPatchConceptsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchConcepts"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchConceptsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiConceptResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchConcepts"))
              .build();
        }
      }
    }
    return getPatchConceptsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetConceptLanguageMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetConceptLanguage",
      requestType = com.clarifai.grpc.api.GetConceptLanguageRequest.class,
      responseType = com.clarifai.grpc.api.SingleConceptLanguageResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetConceptLanguageMethod() {
    io.grpc.MethodDescriptor getGetConceptLanguageMethod;
    if ((getGetConceptLanguageMethod = V2Grpc.getGetConceptLanguageMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetConceptLanguageMethod = V2Grpc.getGetConceptLanguageMethod) == null) {
          V2Grpc.getGetConceptLanguageMethod = getGetConceptLanguageMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetConceptLanguage"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetConceptLanguageRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleConceptLanguageResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetConceptLanguage"))
              .build();
        }
      }
    }
    return getGetConceptLanguageMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListConceptLanguagesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListConceptLanguages",
      requestType = com.clarifai.grpc.api.ListConceptLanguagesRequest.class,
      responseType = com.clarifai.grpc.api.MultiConceptLanguageResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListConceptLanguagesMethod() {
    io.grpc.MethodDescriptor getListConceptLanguagesMethod;
    if ((getListConceptLanguagesMethod = V2Grpc.getListConceptLanguagesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListConceptLanguagesMethod = V2Grpc.getListConceptLanguagesMethod) == null) {
          V2Grpc.getListConceptLanguagesMethod = getListConceptLanguagesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListConceptLanguages"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListConceptLanguagesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiConceptLanguageResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListConceptLanguages"))
              .build();
        }
      }
    }
    return getListConceptLanguagesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostConceptLanguagesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostConceptLanguages",
      requestType = com.clarifai.grpc.api.PostConceptLanguagesRequest.class,
      responseType = com.clarifai.grpc.api.MultiConceptLanguageResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostConceptLanguagesMethod() {
    io.grpc.MethodDescriptor getPostConceptLanguagesMethod;
    if ((getPostConceptLanguagesMethod = V2Grpc.getPostConceptLanguagesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostConceptLanguagesMethod = V2Grpc.getPostConceptLanguagesMethod) == null) {
          V2Grpc.getPostConceptLanguagesMethod = getPostConceptLanguagesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostConceptLanguages"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostConceptLanguagesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiConceptLanguageResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostConceptLanguages"))
              .build();
        }
      }
    }
    return getPostConceptLanguagesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchConceptLanguagesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchConceptLanguages",
      requestType = com.clarifai.grpc.api.PatchConceptLanguagesRequest.class,
      responseType = com.clarifai.grpc.api.MultiConceptLanguageResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchConceptLanguagesMethod() {
    io.grpc.MethodDescriptor getPatchConceptLanguagesMethod;
    if ((getPatchConceptLanguagesMethod = V2Grpc.getPatchConceptLanguagesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchConceptLanguagesMethod = V2Grpc.getPatchConceptLanguagesMethod) == null) {
          V2Grpc.getPatchConceptLanguagesMethod = getPatchConceptLanguagesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchConceptLanguages"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchConceptLanguagesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiConceptLanguageResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchConceptLanguages"))
              .build();
        }
      }
    }
    return getPatchConceptLanguagesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListKnowledgeGraphsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListKnowledgeGraphs",
      requestType = com.clarifai.grpc.api.ListKnowledgeGraphsRequest.class,
      responseType = com.clarifai.grpc.api.MultiKnowledgeGraphResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListKnowledgeGraphsMethod() {
    io.grpc.MethodDescriptor getListKnowledgeGraphsMethod;
    if ((getListKnowledgeGraphsMethod = V2Grpc.getListKnowledgeGraphsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListKnowledgeGraphsMethod = V2Grpc.getListKnowledgeGraphsMethod) == null) {
          V2Grpc.getListKnowledgeGraphsMethod = getListKnowledgeGraphsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListKnowledgeGraphs"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListKnowledgeGraphsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiKnowledgeGraphResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListKnowledgeGraphs"))
              .build();
        }
      }
    }
    return getListKnowledgeGraphsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostKnowledgeGraphsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostKnowledgeGraphs",
      requestType = com.clarifai.grpc.api.PostKnowledgeGraphsRequest.class,
      responseType = com.clarifai.grpc.api.MultiKnowledgeGraphResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostKnowledgeGraphsMethod() {
    io.grpc.MethodDescriptor getPostKnowledgeGraphsMethod;
    if ((getPostKnowledgeGraphsMethod = V2Grpc.getPostKnowledgeGraphsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostKnowledgeGraphsMethod = V2Grpc.getPostKnowledgeGraphsMethod) == null) {
          V2Grpc.getPostKnowledgeGraphsMethod = getPostKnowledgeGraphsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostKnowledgeGraphs"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostKnowledgeGraphsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiKnowledgeGraphResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostKnowledgeGraphs"))
              .build();
        }
      }
    }
    return getPostKnowledgeGraphsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostConceptMappingJobsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostConceptMappingJobs",
      requestType = com.clarifai.grpc.api.PostConceptMappingJobsRequest.class,
      responseType = com.clarifai.grpc.api.MultiConceptMappingJobResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostConceptMappingJobsMethod() {
    io.grpc.MethodDescriptor getPostConceptMappingJobsMethod;
    if ((getPostConceptMappingJobsMethod = V2Grpc.getPostConceptMappingJobsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostConceptMappingJobsMethod = V2Grpc.getPostConceptMappingJobsMethod) == null) {
          V2Grpc.getPostConceptMappingJobsMethod = getPostConceptMappingJobsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostConceptMappingJobs"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostConceptMappingJobsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiConceptMappingJobResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostConceptMappingJobs"))
              .build();
        }
      }
    }
    return getPostConceptMappingJobsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetAnnotationMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetAnnotation",
      requestType = com.clarifai.grpc.api.GetAnnotationRequest.class,
      responseType = com.clarifai.grpc.api.SingleAnnotationResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetAnnotationMethod() {
    io.grpc.MethodDescriptor getGetAnnotationMethod;
    if ((getGetAnnotationMethod = V2Grpc.getGetAnnotationMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetAnnotationMethod = V2Grpc.getGetAnnotationMethod) == null) {
          V2Grpc.getGetAnnotationMethod = getGetAnnotationMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAnnotation"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetAnnotationRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleAnnotationResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetAnnotation"))
              .build();
        }
      }
    }
    return getGetAnnotationMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListAnnotationsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListAnnotations",
      requestType = com.clarifai.grpc.api.ListAnnotationsRequest.class,
      responseType = com.clarifai.grpc.api.MultiAnnotationResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListAnnotationsMethod() {
    io.grpc.MethodDescriptor getListAnnotationsMethod;
    if ((getListAnnotationsMethod = V2Grpc.getListAnnotationsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListAnnotationsMethod = V2Grpc.getListAnnotationsMethod) == null) {
          V2Grpc.getListAnnotationsMethod = getListAnnotationsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListAnnotations"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListAnnotationsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAnnotationResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListAnnotations"))
              .build();
        }
      }
    }
    return getListAnnotationsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostAnnotationsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostAnnotations",
      requestType = com.clarifai.grpc.api.PostAnnotationsRequest.class,
      responseType = com.clarifai.grpc.api.MultiAnnotationResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostAnnotationsMethod() {
    io.grpc.MethodDescriptor getPostAnnotationsMethod;
    if ((getPostAnnotationsMethod = V2Grpc.getPostAnnotationsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostAnnotationsMethod = V2Grpc.getPostAnnotationsMethod) == null) {
          V2Grpc.getPostAnnotationsMethod = getPostAnnotationsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostAnnotations"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostAnnotationsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAnnotationResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostAnnotations"))
              .build();
        }
      }
    }
    return getPostAnnotationsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchAnnotationsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchAnnotations",
      requestType = com.clarifai.grpc.api.PatchAnnotationsRequest.class,
      responseType = com.clarifai.grpc.api.MultiAnnotationResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchAnnotationsMethod() {
    io.grpc.MethodDescriptor getPatchAnnotationsMethod;
    if ((getPatchAnnotationsMethod = V2Grpc.getPatchAnnotationsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchAnnotationsMethod = V2Grpc.getPatchAnnotationsMethod) == null) {
          V2Grpc.getPatchAnnotationsMethod = getPatchAnnotationsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchAnnotations"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchAnnotationsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAnnotationResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchAnnotations"))
              .build();
        }
      }
    }
    return getPatchAnnotationsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchAnnotationsStatusMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchAnnotationsStatus",
      requestType = com.clarifai.grpc.api.PatchAnnotationsStatusRequest.class,
      responseType = com.clarifai.grpc.api.PatchAnnotationsStatusResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchAnnotationsStatusMethod() {
    io.grpc.MethodDescriptor getPatchAnnotationsStatusMethod;
    if ((getPatchAnnotationsStatusMethod = V2Grpc.getPatchAnnotationsStatusMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchAnnotationsStatusMethod = V2Grpc.getPatchAnnotationsStatusMethod) == null) {
          V2Grpc.getPatchAnnotationsStatusMethod = getPatchAnnotationsStatusMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchAnnotationsStatus"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchAnnotationsStatusRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchAnnotationsStatusResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchAnnotationsStatus"))
              .build();
        }
      }
    }
    return getPatchAnnotationsStatusMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteAnnotationMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteAnnotation",
      requestType = com.clarifai.grpc.api.DeleteAnnotationRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteAnnotationMethod() {
    io.grpc.MethodDescriptor getDeleteAnnotationMethod;
    if ((getDeleteAnnotationMethod = V2Grpc.getDeleteAnnotationMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteAnnotationMethod = V2Grpc.getDeleteAnnotationMethod) == null) {
          V2Grpc.getDeleteAnnotationMethod = getDeleteAnnotationMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteAnnotation"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteAnnotationRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteAnnotation"))
              .build();
        }
      }
    }
    return getDeleteAnnotationMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteAnnotationsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteAnnotations",
      requestType = com.clarifai.grpc.api.DeleteAnnotationsRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteAnnotationsMethod() {
    io.grpc.MethodDescriptor getDeleteAnnotationsMethod;
    if ((getDeleteAnnotationsMethod = V2Grpc.getDeleteAnnotationsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteAnnotationsMethod = V2Grpc.getDeleteAnnotationsMethod) == null) {
          V2Grpc.getDeleteAnnotationsMethod = getDeleteAnnotationsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteAnnotations"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteAnnotationsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteAnnotations"))
              .build();
        }
      }
    }
    return getDeleteAnnotationsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostAnnotationsSearchesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostAnnotationsSearches",
      requestType = com.clarifai.grpc.api.PostAnnotationsSearchesRequest.class,
      responseType = com.clarifai.grpc.api.MultiSearchResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostAnnotationsSearchesMethod() {
    io.grpc.MethodDescriptor getPostAnnotationsSearchesMethod;
    if ((getPostAnnotationsSearchesMethod = V2Grpc.getPostAnnotationsSearchesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostAnnotationsSearchesMethod = V2Grpc.getPostAnnotationsSearchesMethod) == null) {
          V2Grpc.getPostAnnotationsSearchesMethod = getPostAnnotationsSearchesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostAnnotationsSearches"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostAnnotationsSearchesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiSearchResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostAnnotationsSearches"))
              .build();
        }
      }
    }
    return getPostAnnotationsSearchesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetInputCountMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetInputCount",
      requestType = com.clarifai.grpc.api.GetInputCountRequest.class,
      responseType = com.clarifai.grpc.api.SingleInputCountResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetInputCountMethod() {
    io.grpc.MethodDescriptor getGetInputCountMethod;
    if ((getGetInputCountMethod = V2Grpc.getGetInputCountMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetInputCountMethod = V2Grpc.getGetInputCountMethod) == null) {
          V2Grpc.getGetInputCountMethod = getGetInputCountMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetInputCount"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetInputCountRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleInputCountResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetInputCount"))
              .build();
        }
      }
    }
    return getGetInputCountMethod;
  }

  private static volatile io.grpc.MethodDescriptor getStreamInputsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "StreamInputs",
      requestType = com.clarifai.grpc.api.StreamInputsRequest.class,
      responseType = com.clarifai.grpc.api.MultiInputResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getStreamInputsMethod() {
    io.grpc.MethodDescriptor getStreamInputsMethod;
    if ((getStreamInputsMethod = V2Grpc.getStreamInputsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getStreamInputsMethod = V2Grpc.getStreamInputsMethod) == null) {
          V2Grpc.getStreamInputsMethod = getStreamInputsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamInputs"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.StreamInputsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiInputResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("StreamInputs"))
              .build();
        }
      }
    }
    return getStreamInputsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetInputSamplesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetInputSamples",
      requestType = com.clarifai.grpc.api.GetInputSamplesRequest.class,
      responseType = com.clarifai.grpc.api.MultiInputAnnotationResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetInputSamplesMethod() {
    io.grpc.MethodDescriptor getGetInputSamplesMethod;
    if ((getGetInputSamplesMethod = V2Grpc.getGetInputSamplesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetInputSamplesMethod = V2Grpc.getGetInputSamplesMethod) == null) {
          V2Grpc.getGetInputSamplesMethod = getGetInputSamplesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetInputSamples"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetInputSamplesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiInputAnnotationResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetInputSamples"))
              .build();
        }
      }
    }
    return getGetInputSamplesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetInputMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetInput",
      requestType = com.clarifai.grpc.api.GetInputRequest.class,
      responseType = com.clarifai.grpc.api.SingleInputResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetInputMethod() {
    io.grpc.MethodDescriptor getGetInputMethod;
    if ((getGetInputMethod = V2Grpc.getGetInputMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetInputMethod = V2Grpc.getGetInputMethod) == null) {
          V2Grpc.getGetInputMethod = getGetInputMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetInput"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetInputRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleInputResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetInput"))
              .build();
        }
      }
    }
    return getGetInputMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListInputsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListInputs",
      requestType = com.clarifai.grpc.api.ListInputsRequest.class,
      responseType = com.clarifai.grpc.api.MultiInputResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListInputsMethod() {
    io.grpc.MethodDescriptor getListInputsMethod;
    if ((getListInputsMethod = V2Grpc.getListInputsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListInputsMethod = V2Grpc.getListInputsMethod) == null) {
          V2Grpc.getListInputsMethod = getListInputsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListInputs"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListInputsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiInputResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListInputs"))
              .build();
        }
      }
    }
    return getListInputsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostInputsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostInputs",
      requestType = com.clarifai.grpc.api.PostInputsRequest.class,
      responseType = com.clarifai.grpc.api.MultiInputResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostInputsMethod() {
    io.grpc.MethodDescriptor getPostInputsMethod;
    if ((getPostInputsMethod = V2Grpc.getPostInputsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostInputsMethod = V2Grpc.getPostInputsMethod) == null) {
          V2Grpc.getPostInputsMethod = getPostInputsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostInputs"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostInputsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiInputResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostInputs"))
              .build();
        }
      }
    }
    return getPostInputsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchInputsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchInputs",
      requestType = com.clarifai.grpc.api.PatchInputsRequest.class,
      responseType = com.clarifai.grpc.api.MultiInputResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchInputsMethod() {
    io.grpc.MethodDescriptor getPatchInputsMethod;
    if ((getPatchInputsMethod = V2Grpc.getPatchInputsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchInputsMethod = V2Grpc.getPatchInputsMethod) == null) {
          V2Grpc.getPatchInputsMethod = getPatchInputsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchInputs"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchInputsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiInputResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchInputs"))
              .build();
        }
      }
    }
    return getPatchInputsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteInputMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteInput",
      requestType = com.clarifai.grpc.api.DeleteInputRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteInputMethod() {
    io.grpc.MethodDescriptor getDeleteInputMethod;
    if ((getDeleteInputMethod = V2Grpc.getDeleteInputMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteInputMethod = V2Grpc.getDeleteInputMethod) == null) {
          V2Grpc.getDeleteInputMethod = getDeleteInputMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteInput"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteInputRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteInput"))
              .build();
        }
      }
    }
    return getDeleteInputMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteInputsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteInputs",
      requestType = com.clarifai.grpc.api.DeleteInputsRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteInputsMethod() {
    io.grpc.MethodDescriptor getDeleteInputsMethod;
    if ((getDeleteInputsMethod = V2Grpc.getDeleteInputsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteInputsMethod = V2Grpc.getDeleteInputsMethod) == null) {
          V2Grpc.getDeleteInputsMethod = getDeleteInputsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteInputs"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteInputsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteInputs"))
              .build();
        }
      }
    }
    return getDeleteInputsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostInputsSearchesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostInputsSearches",
      requestType = com.clarifai.grpc.api.PostInputsSearchesRequest.class,
      responseType = com.clarifai.grpc.api.MultiSearchResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostInputsSearchesMethod() {
    io.grpc.MethodDescriptor getPostInputsSearchesMethod;
    if ((getPostInputsSearchesMethod = V2Grpc.getPostInputsSearchesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostInputsSearchesMethod = V2Grpc.getPostInputsSearchesMethod) == null) {
          V2Grpc.getPostInputsSearchesMethod = getPostInputsSearchesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostInputsSearches"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostInputsSearchesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiSearchResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostInputsSearches"))
              .build();
        }
      }
    }
    return getPostInputsSearchesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostModelOutputsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostModelOutputs",
      requestType = com.clarifai.grpc.api.PostModelOutputsRequest.class,
      responseType = com.clarifai.grpc.api.MultiOutputResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostModelOutputsMethod() {
    io.grpc.MethodDescriptor getPostModelOutputsMethod;
    if ((getPostModelOutputsMethod = V2Grpc.getPostModelOutputsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostModelOutputsMethod = V2Grpc.getPostModelOutputsMethod) == null) {
          V2Grpc.getPostModelOutputsMethod = getPostModelOutputsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostModelOutputs"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostModelOutputsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiOutputResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostModelOutputs"))
              .build();
        }
      }
    }
    return getPostModelOutputsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetModelTypeMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetModelType",
      requestType = com.clarifai.grpc.api.GetModelTypeRequest.class,
      responseType = com.clarifai.grpc.api.SingleModelTypeResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetModelTypeMethod() {
    io.grpc.MethodDescriptor getGetModelTypeMethod;
    if ((getGetModelTypeMethod = V2Grpc.getGetModelTypeMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetModelTypeMethod = V2Grpc.getGetModelTypeMethod) == null) {
          V2Grpc.getGetModelTypeMethod = getGetModelTypeMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetModelType"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetModelTypeRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleModelTypeResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetModelType"))
              .build();
        }
      }
    }
    return getGetModelTypeMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListOpenSourceLicensesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListOpenSourceLicenses",
      requestType = com.clarifai.grpc.api.ListOpenSourceLicensesRequest.class,
      responseType = com.clarifai.grpc.api.ListOpenSourceLicensesResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListOpenSourceLicensesMethod() {
    io.grpc.MethodDescriptor getListOpenSourceLicensesMethod;
    if ((getListOpenSourceLicensesMethod = V2Grpc.getListOpenSourceLicensesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListOpenSourceLicensesMethod = V2Grpc.getListOpenSourceLicensesMethod) == null) {
          V2Grpc.getListOpenSourceLicensesMethod = getListOpenSourceLicensesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListOpenSourceLicenses"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListOpenSourceLicensesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListOpenSourceLicensesResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListOpenSourceLicenses"))
              .build();
        }
      }
    }
    return getListOpenSourceLicensesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListModelTypesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListModelTypes",
      requestType = com.clarifai.grpc.api.ListModelTypesRequest.class,
      responseType = com.clarifai.grpc.api.MultiModelTypeResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListModelTypesMethod() {
    io.grpc.MethodDescriptor getListModelTypesMethod;
    if ((getListModelTypesMethod = V2Grpc.getListModelTypesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListModelTypesMethod = V2Grpc.getListModelTypesMethod) == null) {
          V2Grpc.getListModelTypesMethod = getListModelTypesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListModelTypes"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListModelTypesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiModelTypeResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListModelTypes"))
              .build();
        }
      }
    }
    return getListModelTypesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetModelMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetModel",
      requestType = com.clarifai.grpc.api.GetModelRequest.class,
      responseType = com.clarifai.grpc.api.SingleModelResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetModelMethod() {
    io.grpc.MethodDescriptor getGetModelMethod;
    if ((getGetModelMethod = V2Grpc.getGetModelMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetModelMethod = V2Grpc.getGetModelMethod) == null) {
          V2Grpc.getGetModelMethod = getGetModelMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetModel"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetModelRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleModelResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetModel"))
              .build();
        }
      }
    }
    return getGetModelMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetModelOutputInfoMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetModelOutputInfo",
      requestType = com.clarifai.grpc.api.GetModelRequest.class,
      responseType = com.clarifai.grpc.api.SingleModelResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetModelOutputInfoMethod() {
    io.grpc.MethodDescriptor getGetModelOutputInfoMethod;
    if ((getGetModelOutputInfoMethod = V2Grpc.getGetModelOutputInfoMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetModelOutputInfoMethod = V2Grpc.getGetModelOutputInfoMethod) == null) {
          V2Grpc.getGetModelOutputInfoMethod = getGetModelOutputInfoMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetModelOutputInfo"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetModelRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleModelResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetModelOutputInfo"))
              .build();
        }
      }
    }
    return getGetModelOutputInfoMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListModelsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListModels",
      requestType = com.clarifai.grpc.api.ListModelsRequest.class,
      responseType = com.clarifai.grpc.api.MultiModelResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListModelsMethod() {
    io.grpc.MethodDescriptor getListModelsMethod;
    if ((getListModelsMethod = V2Grpc.getListModelsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListModelsMethod = V2Grpc.getListModelsMethod) == null) {
          V2Grpc.getListModelsMethod = getListModelsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListModels"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListModelsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiModelResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListModels"))
              .build();
        }
      }
    }
    return getListModelsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostModelsSearchesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostModelsSearches",
      requestType = com.clarifai.grpc.api.PostModelsSearchesRequest.class,
      responseType = com.clarifai.grpc.api.MultiModelResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostModelsSearchesMethod() {
    io.grpc.MethodDescriptor getPostModelsSearchesMethod;
    if ((getPostModelsSearchesMethod = V2Grpc.getPostModelsSearchesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostModelsSearchesMethod = V2Grpc.getPostModelsSearchesMethod) == null) {
          V2Grpc.getPostModelsSearchesMethod = getPostModelsSearchesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostModelsSearches"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostModelsSearchesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiModelResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostModelsSearches"))
              .build();
        }
      }
    }
    return getPostModelsSearchesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostModelsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostModels",
      requestType = com.clarifai.grpc.api.PostModelsRequest.class,
      responseType = com.clarifai.grpc.api.SingleModelResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostModelsMethod() {
    io.grpc.MethodDescriptor getPostModelsMethod;
    if ((getPostModelsMethod = V2Grpc.getPostModelsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostModelsMethod = V2Grpc.getPostModelsMethod) == null) {
          V2Grpc.getPostModelsMethod = getPostModelsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostModels"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostModelsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleModelResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostModels"))
              .build();
        }
      }
    }
    return getPostModelsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchModelsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchModels",
      requestType = com.clarifai.grpc.api.PatchModelsRequest.class,
      responseType = com.clarifai.grpc.api.MultiModelResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchModelsMethod() {
    io.grpc.MethodDescriptor getPatchModelsMethod;
    if ((getPatchModelsMethod = V2Grpc.getPatchModelsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchModelsMethod = V2Grpc.getPatchModelsMethod) == null) {
          V2Grpc.getPatchModelsMethod = getPatchModelsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchModels"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchModelsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiModelResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchModels"))
              .build();
        }
      }
    }
    return getPatchModelsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteModelMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteModel",
      requestType = com.clarifai.grpc.api.DeleteModelRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteModelMethod() {
    io.grpc.MethodDescriptor getDeleteModelMethod;
    if ((getDeleteModelMethod = V2Grpc.getDeleteModelMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteModelMethod = V2Grpc.getDeleteModelMethod) == null) {
          V2Grpc.getDeleteModelMethod = getDeleteModelMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteModel"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteModelRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteModel"))
              .build();
        }
      }
    }
    return getDeleteModelMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteModelsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteModels",
      requestType = com.clarifai.grpc.api.DeleteModelsRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteModelsMethod() {
    io.grpc.MethodDescriptor getDeleteModelsMethod;
    if ((getDeleteModelsMethod = V2Grpc.getDeleteModelsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteModelsMethod = V2Grpc.getDeleteModelsMethod) == null) {
          V2Grpc.getDeleteModelsMethod = getDeleteModelsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteModels"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteModelsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteModels"))
              .build();
        }
      }
    }
    return getDeleteModelsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchModelToolkitsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchModelToolkits",
      requestType = com.clarifai.grpc.api.PatchModelToolkitsRequest.class,
      responseType = com.clarifai.grpc.api.MultiModelToolkitResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchModelToolkitsMethod() {
    io.grpc.MethodDescriptor getPatchModelToolkitsMethod;
    if ((getPatchModelToolkitsMethod = V2Grpc.getPatchModelToolkitsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchModelToolkitsMethod = V2Grpc.getPatchModelToolkitsMethod) == null) {
          V2Grpc.getPatchModelToolkitsMethod = getPatchModelToolkitsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchModelToolkits"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchModelToolkitsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiModelToolkitResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchModelToolkits"))
              .build();
        }
      }
    }
    return getPatchModelToolkitsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchModelUseCasesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchModelUseCases",
      requestType = com.clarifai.grpc.api.PatchModelUseCasesRequest.class,
      responseType = com.clarifai.grpc.api.MultiModelUseCaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchModelUseCasesMethod() {
    io.grpc.MethodDescriptor getPatchModelUseCasesMethod;
    if ((getPatchModelUseCasesMethod = V2Grpc.getPatchModelUseCasesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchModelUseCasesMethod = V2Grpc.getPatchModelUseCasesMethod) == null) {
          V2Grpc.getPatchModelUseCasesMethod = getPatchModelUseCasesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchModelUseCases"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchModelUseCasesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiModelUseCaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchModelUseCases"))
              .build();
        }
      }
    }
    return getPatchModelUseCasesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchModelLanguagesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchModelLanguages",
      requestType = com.clarifai.grpc.api.PatchModelLanguagesRequest.class,
      responseType = com.clarifai.grpc.api.MultiModelLanguageResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchModelLanguagesMethod() {
    io.grpc.MethodDescriptor getPatchModelLanguagesMethod;
    if ((getPatchModelLanguagesMethod = V2Grpc.getPatchModelLanguagesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchModelLanguagesMethod = V2Grpc.getPatchModelLanguagesMethod) == null) {
          V2Grpc.getPatchModelLanguagesMethod = getPatchModelLanguagesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchModelLanguages"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchModelLanguagesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiModelLanguageResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchModelLanguages"))
              .build();
        }
      }
    }
    return getPatchModelLanguagesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListModelInputsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListModelInputs",
      requestType = com.clarifai.grpc.api.ListModelInputsRequest.class,
      responseType = com.clarifai.grpc.api.MultiInputResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListModelInputsMethod() {
    io.grpc.MethodDescriptor getListModelInputsMethod;
    if ((getListModelInputsMethod = V2Grpc.getListModelInputsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListModelInputsMethod = V2Grpc.getListModelInputsMethod) == null) {
          V2Grpc.getListModelInputsMethod = getListModelInputsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListModelInputs"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListModelInputsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiInputResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListModelInputs"))
              .build();
        }
      }
    }
    return getListModelInputsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetModelVersionMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetModelVersion",
      requestType = com.clarifai.grpc.api.GetModelVersionRequest.class,
      responseType = com.clarifai.grpc.api.SingleModelVersionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetModelVersionMethod() {
    io.grpc.MethodDescriptor getGetModelVersionMethod;
    if ((getGetModelVersionMethod = V2Grpc.getGetModelVersionMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetModelVersionMethod = V2Grpc.getGetModelVersionMethod) == null) {
          V2Grpc.getGetModelVersionMethod = getGetModelVersionMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetModelVersion"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetModelVersionRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleModelVersionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetModelVersion"))
              .build();
        }
      }
    }
    return getGetModelVersionMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListModelVersionsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListModelVersions",
      requestType = com.clarifai.grpc.api.ListModelVersionsRequest.class,
      responseType = com.clarifai.grpc.api.MultiModelVersionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListModelVersionsMethod() {
    io.grpc.MethodDescriptor getListModelVersionsMethod;
    if ((getListModelVersionsMethod = V2Grpc.getListModelVersionsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListModelVersionsMethod = V2Grpc.getListModelVersionsMethod) == null) {
          V2Grpc.getListModelVersionsMethod = getListModelVersionsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListModelVersions"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListModelVersionsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiModelVersionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListModelVersions"))
              .build();
        }
      }
    }
    return getListModelVersionsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostModelVersionsPublishMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostModelVersionsPublish",
      requestType = com.clarifai.grpc.api.PostModelVersionsPublishRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostModelVersionsPublishMethod() {
    io.grpc.MethodDescriptor getPostModelVersionsPublishMethod;
    if ((getPostModelVersionsPublishMethod = V2Grpc.getPostModelVersionsPublishMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostModelVersionsPublishMethod = V2Grpc.getPostModelVersionsPublishMethod) == null) {
          V2Grpc.getPostModelVersionsPublishMethod = getPostModelVersionsPublishMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostModelVersionsPublish"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostModelVersionsPublishRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostModelVersionsPublish"))
              .build();
        }
      }
    }
    return getPostModelVersionsPublishMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostModelVersionsUnPublishMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostModelVersionsUnPublish",
      requestType = com.clarifai.grpc.api.PostModelVersionsUnPublishRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostModelVersionsUnPublishMethod() {
    io.grpc.MethodDescriptor getPostModelVersionsUnPublishMethod;
    if ((getPostModelVersionsUnPublishMethod = V2Grpc.getPostModelVersionsUnPublishMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostModelVersionsUnPublishMethod = V2Grpc.getPostModelVersionsUnPublishMethod) == null) {
          V2Grpc.getPostModelVersionsUnPublishMethod = getPostModelVersionsUnPublishMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostModelVersionsUnPublish"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostModelVersionsUnPublishRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostModelVersionsUnPublish"))
              .build();
        }
      }
    }
    return getPostModelVersionsUnPublishMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostModelVersionsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostModelVersions",
      requestType = com.clarifai.grpc.api.PostModelVersionsRequest.class,
      responseType = com.clarifai.grpc.api.SingleModelResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostModelVersionsMethod() {
    io.grpc.MethodDescriptor getPostModelVersionsMethod;
    if ((getPostModelVersionsMethod = V2Grpc.getPostModelVersionsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostModelVersionsMethod = V2Grpc.getPostModelVersionsMethod) == null) {
          V2Grpc.getPostModelVersionsMethod = getPostModelVersionsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostModelVersions"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostModelVersionsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleModelResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostModelVersions"))
              .build();
        }
      }
    }
    return getPostModelVersionsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchModelVersionsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchModelVersions",
      requestType = com.clarifai.grpc.api.PatchModelVersionsRequest.class,
      responseType = com.clarifai.grpc.api.MultiModelVersionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchModelVersionsMethod() {
    io.grpc.MethodDescriptor getPatchModelVersionsMethod;
    if ((getPatchModelVersionsMethod = V2Grpc.getPatchModelVersionsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchModelVersionsMethod = V2Grpc.getPatchModelVersionsMethod) == null) {
          V2Grpc.getPatchModelVersionsMethod = getPatchModelVersionsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchModelVersions"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchModelVersionsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiModelVersionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchModelVersions"))
              .build();
        }
      }
    }
    return getPatchModelVersionsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteModelVersionMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteModelVersion",
      requestType = com.clarifai.grpc.api.DeleteModelVersionRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteModelVersionMethod() {
    io.grpc.MethodDescriptor getDeleteModelVersionMethod;
    if ((getDeleteModelVersionMethod = V2Grpc.getDeleteModelVersionMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteModelVersionMethod = V2Grpc.getDeleteModelVersionMethod) == null) {
          V2Grpc.getDeleteModelVersionMethod = getDeleteModelVersionMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteModelVersion"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteModelVersionRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteModelVersion"))
              .build();
        }
      }
    }
    return getDeleteModelVersionMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetModelVersionMetricsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetModelVersionMetrics",
      requestType = com.clarifai.grpc.api.GetModelVersionMetricsRequest.class,
      responseType = com.clarifai.grpc.api.SingleModelVersionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetModelVersionMetricsMethod() {
    io.grpc.MethodDescriptor getGetModelVersionMetricsMethod;
    if ((getGetModelVersionMetricsMethod = V2Grpc.getGetModelVersionMetricsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetModelVersionMetricsMethod = V2Grpc.getGetModelVersionMetricsMethod) == null) {
          V2Grpc.getGetModelVersionMetricsMethod = getGetModelVersionMetricsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetModelVersionMetrics"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetModelVersionMetricsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleModelVersionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetModelVersionMetrics"))
              .build();
        }
      }
    }
    return getGetModelVersionMetricsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostModelVersionMetricsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostModelVersionMetrics",
      requestType = com.clarifai.grpc.api.PostModelVersionMetricsRequest.class,
      responseType = com.clarifai.grpc.api.SingleModelVersionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostModelVersionMetricsMethod() {
    io.grpc.MethodDescriptor getPostModelVersionMetricsMethod;
    if ((getPostModelVersionMetricsMethod = V2Grpc.getPostModelVersionMetricsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostModelVersionMetricsMethod = V2Grpc.getPostModelVersionMetricsMethod) == null) {
          V2Grpc.getPostModelVersionMetricsMethod = getPostModelVersionMetricsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostModelVersionMetrics"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostModelVersionMetricsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleModelVersionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostModelVersionMetrics"))
              .build();
        }
      }
    }
    return getPostModelVersionMetricsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListModelReferencesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListModelReferences",
      requestType = com.clarifai.grpc.api.ListModelReferencesRequest.class,
      responseType = com.clarifai.grpc.api.MultiModelReferenceResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListModelReferencesMethod() {
    io.grpc.MethodDescriptor getListModelReferencesMethod;
    if ((getListModelReferencesMethod = V2Grpc.getListModelReferencesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListModelReferencesMethod = V2Grpc.getListModelReferencesMethod) == null) {
          V2Grpc.getListModelReferencesMethod = getListModelReferencesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListModelReferences"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListModelReferencesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiModelReferenceResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListModelReferences"))
              .build();
        }
      }
    }
    return getListModelReferencesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetModelVersionInputExampleMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetModelVersionInputExample",
      requestType = com.clarifai.grpc.api.GetModelVersionInputExampleRequest.class,
      responseType = com.clarifai.grpc.api.SingleModelVersionInputExampleResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetModelVersionInputExampleMethod() {
    io.grpc.MethodDescriptor getGetModelVersionInputExampleMethod;
    if ((getGetModelVersionInputExampleMethod = V2Grpc.getGetModelVersionInputExampleMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetModelVersionInputExampleMethod = V2Grpc.getGetModelVersionInputExampleMethod) == null) {
          V2Grpc.getGetModelVersionInputExampleMethod = getGetModelVersionInputExampleMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetModelVersionInputExample"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetModelVersionInputExampleRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleModelVersionInputExampleResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetModelVersionInputExample"))
              .build();
        }
      }
    }
    return getGetModelVersionInputExampleMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListModelVersionInputExamplesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListModelVersionInputExamples",
      requestType = com.clarifai.grpc.api.ListModelVersionInputExamplesRequest.class,
      responseType = com.clarifai.grpc.api.MultiModelVersionInputExampleResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListModelVersionInputExamplesMethod() {
    io.grpc.MethodDescriptor getListModelVersionInputExamplesMethod;
    if ((getListModelVersionInputExamplesMethod = V2Grpc.getListModelVersionInputExamplesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListModelVersionInputExamplesMethod = V2Grpc.getListModelVersionInputExamplesMethod) == null) {
          V2Grpc.getListModelVersionInputExamplesMethod = getListModelVersionInputExamplesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListModelVersionInputExamples"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListModelVersionInputExamplesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiModelVersionInputExampleResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListModelVersionInputExamples"))
              .build();
        }
      }
    }
    return getListModelVersionInputExamplesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetWorkflowMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetWorkflow",
      requestType = com.clarifai.grpc.api.GetWorkflowRequest.class,
      responseType = com.clarifai.grpc.api.SingleWorkflowResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetWorkflowMethod() {
    io.grpc.MethodDescriptor getGetWorkflowMethod;
    if ((getGetWorkflowMethod = V2Grpc.getGetWorkflowMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetWorkflowMethod = V2Grpc.getGetWorkflowMethod) == null) {
          V2Grpc.getGetWorkflowMethod = getGetWorkflowMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetWorkflow"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetWorkflowRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleWorkflowResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetWorkflow"))
              .build();
        }
      }
    }
    return getGetWorkflowMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListWorkflowsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListWorkflows",
      requestType = com.clarifai.grpc.api.ListWorkflowsRequest.class,
      responseType = com.clarifai.grpc.api.MultiWorkflowResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListWorkflowsMethod() {
    io.grpc.MethodDescriptor getListWorkflowsMethod;
    if ((getListWorkflowsMethod = V2Grpc.getListWorkflowsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListWorkflowsMethod = V2Grpc.getListWorkflowsMethod) == null) {
          V2Grpc.getListWorkflowsMethod = getListWorkflowsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListWorkflows"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListWorkflowsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiWorkflowResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListWorkflows"))
              .build();
        }
      }
    }
    return getListWorkflowsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostWorkflowsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostWorkflows",
      requestType = com.clarifai.grpc.api.PostWorkflowsRequest.class,
      responseType = com.clarifai.grpc.api.MultiWorkflowResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostWorkflowsMethod() {
    io.grpc.MethodDescriptor getPostWorkflowsMethod;
    if ((getPostWorkflowsMethod = V2Grpc.getPostWorkflowsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostWorkflowsMethod = V2Grpc.getPostWorkflowsMethod) == null) {
          V2Grpc.getPostWorkflowsMethod = getPostWorkflowsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostWorkflows"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostWorkflowsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiWorkflowResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostWorkflows"))
              .build();
        }
      }
    }
    return getPostWorkflowsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchWorkflowsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchWorkflows",
      requestType = com.clarifai.grpc.api.PatchWorkflowsRequest.class,
      responseType = com.clarifai.grpc.api.MultiWorkflowResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchWorkflowsMethod() {
    io.grpc.MethodDescriptor getPatchWorkflowsMethod;
    if ((getPatchWorkflowsMethod = V2Grpc.getPatchWorkflowsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchWorkflowsMethod = V2Grpc.getPatchWorkflowsMethod) == null) {
          V2Grpc.getPatchWorkflowsMethod = getPatchWorkflowsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchWorkflows"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchWorkflowsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiWorkflowResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchWorkflows"))
              .build();
        }
      }
    }
    return getPatchWorkflowsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteWorkflowMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteWorkflow",
      requestType = com.clarifai.grpc.api.DeleteWorkflowRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteWorkflowMethod() {
    io.grpc.MethodDescriptor getDeleteWorkflowMethod;
    if ((getDeleteWorkflowMethod = V2Grpc.getDeleteWorkflowMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteWorkflowMethod = V2Grpc.getDeleteWorkflowMethod) == null) {
          V2Grpc.getDeleteWorkflowMethod = getDeleteWorkflowMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteWorkflow"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteWorkflowRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteWorkflow"))
              .build();
        }
      }
    }
    return getDeleteWorkflowMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteWorkflowsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteWorkflows",
      requestType = com.clarifai.grpc.api.DeleteWorkflowsRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteWorkflowsMethod() {
    io.grpc.MethodDescriptor getDeleteWorkflowsMethod;
    if ((getDeleteWorkflowsMethod = V2Grpc.getDeleteWorkflowsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteWorkflowsMethod = V2Grpc.getDeleteWorkflowsMethod) == null) {
          V2Grpc.getDeleteWorkflowsMethod = getDeleteWorkflowsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteWorkflows"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteWorkflowsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteWorkflows"))
              .build();
        }
      }
    }
    return getDeleteWorkflowsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostWorkflowResultsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostWorkflowResults",
      requestType = com.clarifai.grpc.api.PostWorkflowResultsRequest.class,
      responseType = com.clarifai.grpc.api.PostWorkflowResultsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostWorkflowResultsMethod() {
    io.grpc.MethodDescriptor getPostWorkflowResultsMethod;
    if ((getPostWorkflowResultsMethod = V2Grpc.getPostWorkflowResultsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostWorkflowResultsMethod = V2Grpc.getPostWorkflowResultsMethod) == null) {
          V2Grpc.getPostWorkflowResultsMethod = getPostWorkflowResultsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostWorkflowResults"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostWorkflowResultsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostWorkflowResultsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostWorkflowResults"))
              .build();
        }
      }
    }
    return getPostWorkflowResultsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostWorkflowResultsSimilarityMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostWorkflowResultsSimilarity",
      requestType = com.clarifai.grpc.api.PostWorkflowResultsSimilarityRequest.class,
      responseType = com.clarifai.grpc.api.PostWorkflowResultsSimilarityResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostWorkflowResultsSimilarityMethod() {
    io.grpc.MethodDescriptor getPostWorkflowResultsSimilarityMethod;
    if ((getPostWorkflowResultsSimilarityMethod = V2Grpc.getPostWorkflowResultsSimilarityMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostWorkflowResultsSimilarityMethod = V2Grpc.getPostWorkflowResultsSimilarityMethod) == null) {
          V2Grpc.getPostWorkflowResultsSimilarityMethod = getPostWorkflowResultsSimilarityMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostWorkflowResultsSimilarity"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostWorkflowResultsSimilarityRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostWorkflowResultsSimilarityResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostWorkflowResultsSimilarity"))
              .build();
        }
      }
    }
    return getPostWorkflowResultsSimilarityMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListWorkflowVersionsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListWorkflowVersions",
      requestType = com.clarifai.grpc.api.ListWorkflowVersionsRequest.class,
      responseType = com.clarifai.grpc.api.MultiWorkflowVersionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListWorkflowVersionsMethod() {
    io.grpc.MethodDescriptor getListWorkflowVersionsMethod;
    if ((getListWorkflowVersionsMethod = V2Grpc.getListWorkflowVersionsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListWorkflowVersionsMethod = V2Grpc.getListWorkflowVersionsMethod) == null) {
          V2Grpc.getListWorkflowVersionsMethod = getListWorkflowVersionsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListWorkflowVersions"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListWorkflowVersionsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiWorkflowVersionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListWorkflowVersions"))
              .build();
        }
      }
    }
    return getListWorkflowVersionsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetWorkflowVersionMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetWorkflowVersion",
      requestType = com.clarifai.grpc.api.GetWorkflowVersionRequest.class,
      responseType = com.clarifai.grpc.api.SingleWorkflowVersionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetWorkflowVersionMethod() {
    io.grpc.MethodDescriptor getGetWorkflowVersionMethod;
    if ((getGetWorkflowVersionMethod = V2Grpc.getGetWorkflowVersionMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetWorkflowVersionMethod = V2Grpc.getGetWorkflowVersionMethod) == null) {
          V2Grpc.getGetWorkflowVersionMethod = getGetWorkflowVersionMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetWorkflowVersion"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetWorkflowVersionRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleWorkflowVersionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetWorkflowVersion"))
              .build();
        }
      }
    }
    return getGetWorkflowVersionMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteWorkflowVersionsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteWorkflowVersions",
      requestType = com.clarifai.grpc.api.DeleteWorkflowVersionsRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteWorkflowVersionsMethod() {
    io.grpc.MethodDescriptor getDeleteWorkflowVersionsMethod;
    if ((getDeleteWorkflowVersionsMethod = V2Grpc.getDeleteWorkflowVersionsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteWorkflowVersionsMethod = V2Grpc.getDeleteWorkflowVersionsMethod) == null) {
          V2Grpc.getDeleteWorkflowVersionsMethod = getDeleteWorkflowVersionsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteWorkflowVersions"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteWorkflowVersionsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteWorkflowVersions"))
              .build();
        }
      }
    }
    return getDeleteWorkflowVersionsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchWorkflowVersionsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchWorkflowVersions",
      requestType = com.clarifai.grpc.api.PatchWorkflowVersionsRequest.class,
      responseType = com.clarifai.grpc.api.MultiWorkflowVersionResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchWorkflowVersionsMethod() {
    io.grpc.MethodDescriptor getPatchWorkflowVersionsMethod;
    if ((getPatchWorkflowVersionsMethod = V2Grpc.getPatchWorkflowVersionsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchWorkflowVersionsMethod = V2Grpc.getPatchWorkflowVersionsMethod) == null) {
          V2Grpc.getPatchWorkflowVersionsMethod = getPatchWorkflowVersionsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchWorkflowVersions"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchWorkflowVersionsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiWorkflowVersionResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchWorkflowVersions"))
              .build();
        }
      }
    }
    return getPatchWorkflowVersionsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetKeyMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetKey",
      requestType = com.clarifai.grpc.api.GetKeyRequest.class,
      responseType = com.clarifai.grpc.api.SingleKeyResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetKeyMethod() {
    io.grpc.MethodDescriptor getGetKeyMethod;
    if ((getGetKeyMethod = V2Grpc.getGetKeyMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetKeyMethod = V2Grpc.getGetKeyMethod) == null) {
          V2Grpc.getGetKeyMethod = getGetKeyMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetKey"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetKeyRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleKeyResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetKey"))
              .build();
        }
      }
    }
    return getGetKeyMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListKeysMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListKeys",
      requestType = com.clarifai.grpc.api.ListKeysRequest.class,
      responseType = com.clarifai.grpc.api.MultiKeyResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListKeysMethod() {
    io.grpc.MethodDescriptor getListKeysMethod;
    if ((getListKeysMethod = V2Grpc.getListKeysMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListKeysMethod = V2Grpc.getListKeysMethod) == null) {
          V2Grpc.getListKeysMethod = getListKeysMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListKeys"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListKeysRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiKeyResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListKeys"))
              .build();
        }
      }
    }
    return getListKeysMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListAppKeysMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListAppKeys",
      requestType = com.clarifai.grpc.api.ListAppKeysRequest.class,
      responseType = com.clarifai.grpc.api.MultiKeyResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListAppKeysMethod() {
    io.grpc.MethodDescriptor getListAppKeysMethod;
    if ((getListAppKeysMethod = V2Grpc.getListAppKeysMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListAppKeysMethod = V2Grpc.getListAppKeysMethod) == null) {
          V2Grpc.getListAppKeysMethod = getListAppKeysMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListAppKeys"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListAppKeysRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiKeyResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListAppKeys"))
              .build();
        }
      }
    }
    return getListAppKeysMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteKeyMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteKey",
      requestType = com.clarifai.grpc.api.DeleteKeyRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteKeyMethod() {
    io.grpc.MethodDescriptor getDeleteKeyMethod;
    if ((getDeleteKeyMethod = V2Grpc.getDeleteKeyMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteKeyMethod = V2Grpc.getDeleteKeyMethod) == null) {
          V2Grpc.getDeleteKeyMethod = getDeleteKeyMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteKey"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteKeyRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteKey"))
              .build();
        }
      }
    }
    return getDeleteKeyMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostKeysMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostKeys",
      requestType = com.clarifai.grpc.api.PostKeysRequest.class,
      responseType = com.clarifai.grpc.api.MultiKeyResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostKeysMethod() {
    io.grpc.MethodDescriptor getPostKeysMethod;
    if ((getPostKeysMethod = V2Grpc.getPostKeysMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostKeysMethod = V2Grpc.getPostKeysMethod) == null) {
          V2Grpc.getPostKeysMethod = getPostKeysMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostKeys"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostKeysRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiKeyResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostKeys"))
              .build();
        }
      }
    }
    return getPostKeysMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchKeysMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchKeys",
      requestType = com.clarifai.grpc.api.PatchKeysRequest.class,
      responseType = com.clarifai.grpc.api.MultiKeyResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchKeysMethod() {
    io.grpc.MethodDescriptor getPatchKeysMethod;
    if ((getPatchKeysMethod = V2Grpc.getPatchKeysMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchKeysMethod = V2Grpc.getPatchKeysMethod) == null) {
          V2Grpc.getPatchKeysMethod = getPatchKeysMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchKeys"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchKeysRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiKeyResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchKeys"))
              .build();
        }
      }
    }
    return getPatchKeysMethod;
  }

  private static volatile io.grpc.MethodDescriptor getMyScopesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "MyScopes",
      requestType = com.clarifai.grpc.api.MyScopesRequest.class,
      responseType = com.clarifai.grpc.api.MultiScopeResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getMyScopesMethod() {
    io.grpc.MethodDescriptor getMyScopesMethod;
    if ((getMyScopesMethod = V2Grpc.getMyScopesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getMyScopesMethod = V2Grpc.getMyScopesMethod) == null) {
          V2Grpc.getMyScopesMethod = getMyScopesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "MyScopes"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MyScopesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiScopeResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("MyScopes"))
              .build();
        }
      }
    }
    return getMyScopesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getMyScopesUserMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "MyScopesUser",
      requestType = com.clarifai.grpc.api.MyScopesUserRequest.class,
      responseType = com.clarifai.grpc.api.MultiScopeUserResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getMyScopesUserMethod() {
    io.grpc.MethodDescriptor getMyScopesUserMethod;
    if ((getMyScopesUserMethod = V2Grpc.getMyScopesUserMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getMyScopesUserMethod = V2Grpc.getMyScopesUserMethod) == null) {
          V2Grpc.getMyScopesUserMethod = getMyScopesUserMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "MyScopesUser"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MyScopesUserRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiScopeUserResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("MyScopesUser"))
              .build();
        }
      }
    }
    return getMyScopesUserMethod;
  }

  private static volatile io.grpc.MethodDescriptor getMyScopesRootMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "MyScopesRoot",
      requestType = com.clarifai.grpc.api.MyScopesRootRequest.class,
      responseType = com.clarifai.grpc.api.MultiScopeRootResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getMyScopesRootMethod() {
    io.grpc.MethodDescriptor getMyScopesRootMethod;
    if ((getMyScopesRootMethod = V2Grpc.getMyScopesRootMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getMyScopesRootMethod = V2Grpc.getMyScopesRootMethod) == null) {
          V2Grpc.getMyScopesRootMethod = getMyScopesRootMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "MyScopesRoot"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MyScopesRootRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiScopeRootResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("MyScopesRoot"))
              .build();
        }
      }
    }
    return getMyScopesRootMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListScopesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListScopes",
      requestType = com.clarifai.grpc.api.ListScopesRequest.class,
      responseType = com.clarifai.grpc.api.MultiScopeDepsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListScopesMethod() {
    io.grpc.MethodDescriptor getListScopesMethod;
    if ((getListScopesMethod = V2Grpc.getListScopesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListScopesMethod = V2Grpc.getListScopesMethod) == null) {
          V2Grpc.getListScopesMethod = getListScopesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListScopes"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListScopesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiScopeDepsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListScopes"))
              .build();
        }
      }
    }
    return getListScopesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetAppMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetApp",
      requestType = com.clarifai.grpc.api.GetAppRequest.class,
      responseType = com.clarifai.grpc.api.SingleAppResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetAppMethod() {
    io.grpc.MethodDescriptor getGetAppMethod;
    if ((getGetAppMethod = V2Grpc.getGetAppMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetAppMethod = V2Grpc.getGetAppMethod) == null) {
          V2Grpc.getGetAppMethod = getGetAppMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetApp"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetAppRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleAppResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetApp"))
              .build();
        }
      }
    }
    return getGetAppMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListAppsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListApps",
      requestType = com.clarifai.grpc.api.ListAppsRequest.class,
      responseType = com.clarifai.grpc.api.MultiAppResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListAppsMethod() {
    io.grpc.MethodDescriptor getListAppsMethod;
    if ((getListAppsMethod = V2Grpc.getListAppsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListAppsMethod = V2Grpc.getListAppsMethod) == null) {
          V2Grpc.getListAppsMethod = getListAppsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListApps"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListAppsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAppResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListApps"))
              .build();
        }
      }
    }
    return getListAppsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteAppMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteApp",
      requestType = com.clarifai.grpc.api.DeleteAppRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteAppMethod() {
    io.grpc.MethodDescriptor getDeleteAppMethod;
    if ((getDeleteAppMethod = V2Grpc.getDeleteAppMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteAppMethod = V2Grpc.getDeleteAppMethod) == null) {
          V2Grpc.getDeleteAppMethod = getDeleteAppMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteApp"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteAppRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteApp"))
              .build();
        }
      }
    }
    return getDeleteAppMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostAppsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostApps",
      requestType = com.clarifai.grpc.api.PostAppsRequest.class,
      responseType = com.clarifai.grpc.api.MultiAppResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostAppsMethod() {
    io.grpc.MethodDescriptor getPostAppsMethod;
    if ((getPostAppsMethod = V2Grpc.getPostAppsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostAppsMethod = V2Grpc.getPostAppsMethod) == null) {
          V2Grpc.getPostAppsMethod = getPostAppsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostApps"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostAppsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAppResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostApps"))
              .build();
        }
      }
    }
    return getPostAppsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchAppsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchApps",
      requestType = com.clarifai.grpc.api.PatchAppsRequest.class,
      responseType = com.clarifai.grpc.api.MultiAppResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchAppsMethod() {
    io.grpc.MethodDescriptor getPatchAppsMethod;
    if ((getPatchAppsMethod = V2Grpc.getPatchAppsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchAppsMethod = V2Grpc.getPatchAppsMethod) == null) {
          V2Grpc.getPatchAppsMethod = getPatchAppsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchApps"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchAppsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAppResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchApps"))
              .build();
        }
      }
    }
    return getPatchAppsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostAppsSearchesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostAppsSearches",
      requestType = com.clarifai.grpc.api.PostAppsSearchesRequest.class,
      responseType = com.clarifai.grpc.api.MultiAppResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostAppsSearchesMethod() {
    io.grpc.MethodDescriptor getPostAppsSearchesMethod;
    if ((getPostAppsSearchesMethod = V2Grpc.getPostAppsSearchesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostAppsSearchesMethod = V2Grpc.getPostAppsSearchesMethod) == null) {
          V2Grpc.getPostAppsSearchesMethod = getPostAppsSearchesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostAppsSearches"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostAppsSearchesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAppResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostAppsSearches"))
              .build();
        }
      }
    }
    return getPostAppsSearchesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostValidatePasswordMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostValidatePassword",
      requestType = com.clarifai.grpc.api.PostValidatePasswordRequest.class,
      responseType = com.clarifai.grpc.api.SinglePasswordValidationResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostValidatePasswordMethod() {
    io.grpc.MethodDescriptor getPostValidatePasswordMethod;
    if ((getPostValidatePasswordMethod = V2Grpc.getPostValidatePasswordMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostValidatePasswordMethod = V2Grpc.getPostValidatePasswordMethod) == null) {
          V2Grpc.getPostValidatePasswordMethod = getPostValidatePasswordMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostValidatePassword"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostValidatePasswordRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SinglePasswordValidationResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostValidatePassword"))
              .build();
        }
      }
    }
    return getPostValidatePasswordMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetSearchMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetSearch",
      requestType = com.clarifai.grpc.api.GetSearchRequest.class,
      responseType = com.clarifai.grpc.api.SingleSearchResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetSearchMethod() {
    io.grpc.MethodDescriptor getGetSearchMethod;
    if ((getGetSearchMethod = V2Grpc.getGetSearchMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetSearchMethod = V2Grpc.getGetSearchMethod) == null) {
          V2Grpc.getGetSearchMethod = getGetSearchMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSearch"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetSearchRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleSearchResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetSearch"))
              .build();
        }
      }
    }
    return getGetSearchMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListSearchesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListSearches",
      requestType = com.clarifai.grpc.api.ListSearchesRequest.class,
      responseType = com.clarifai.grpc.api.MultiSearchResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListSearchesMethod() {
    io.grpc.MethodDescriptor getListSearchesMethod;
    if ((getListSearchesMethod = V2Grpc.getListSearchesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListSearchesMethod = V2Grpc.getListSearchesMethod) == null) {
          V2Grpc.getListSearchesMethod = getListSearchesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListSearches"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListSearchesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiSearchResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListSearches"))
              .build();
        }
      }
    }
    return getListSearchesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostSearchesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostSearches",
      requestType = com.clarifai.grpc.api.PostSearchesRequest.class,
      responseType = com.clarifai.grpc.api.MultiSearchResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostSearchesMethod() {
    io.grpc.MethodDescriptor getPostSearchesMethod;
    if ((getPostSearchesMethod = V2Grpc.getPostSearchesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostSearchesMethod = V2Grpc.getPostSearchesMethod) == null) {
          V2Grpc.getPostSearchesMethod = getPostSearchesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostSearches"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostSearchesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiSearchResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostSearches"))
              .build();
        }
      }
    }
    return getPostSearchesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostSearchesByIDMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostSearchesByID",
      requestType = com.clarifai.grpc.api.PostSearchesByIDRequest.class,
      responseType = com.clarifai.grpc.api.MultiSearchResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostSearchesByIDMethod() {
    io.grpc.MethodDescriptor getPostSearchesByIDMethod;
    if ((getPostSearchesByIDMethod = V2Grpc.getPostSearchesByIDMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostSearchesByIDMethod = V2Grpc.getPostSearchesByIDMethod) == null) {
          V2Grpc.getPostSearchesByIDMethod = getPostSearchesByIDMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostSearchesByID"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostSearchesByIDRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiSearchResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostSearchesByID"))
              .build();
        }
      }
    }
    return getPostSearchesByIDMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostAnnotationSearchMetricsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostAnnotationSearchMetrics",
      requestType = com.clarifai.grpc.api.PostAnnotationSearchMetricsRequest.class,
      responseType = com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostAnnotationSearchMetricsMethod() {
    io.grpc.MethodDescriptor getPostAnnotationSearchMetricsMethod;
    if ((getPostAnnotationSearchMetricsMethod = V2Grpc.getPostAnnotationSearchMetricsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostAnnotationSearchMetricsMethod = V2Grpc.getPostAnnotationSearchMetricsMethod) == null) {
          V2Grpc.getPostAnnotationSearchMetricsMethod = getPostAnnotationSearchMetricsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostAnnotationSearchMetrics"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostAnnotationSearchMetricsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostAnnotationSearchMetrics"))
              .build();
        }
      }
    }
    return getPostAnnotationSearchMetricsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetAnnotationSearchMetricsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetAnnotationSearchMetrics",
      requestType = com.clarifai.grpc.api.GetAnnotationSearchMetricsRequest.class,
      responseType = com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetAnnotationSearchMetricsMethod() {
    io.grpc.MethodDescriptor getGetAnnotationSearchMetricsMethod;
    if ((getGetAnnotationSearchMetricsMethod = V2Grpc.getGetAnnotationSearchMetricsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetAnnotationSearchMetricsMethod = V2Grpc.getGetAnnotationSearchMetricsMethod) == null) {
          V2Grpc.getGetAnnotationSearchMetricsMethod = getGetAnnotationSearchMetricsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAnnotationSearchMetrics"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetAnnotationSearchMetricsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetAnnotationSearchMetrics"))
              .build();
        }
      }
    }
    return getGetAnnotationSearchMetricsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListAnnotationSearchMetricsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListAnnotationSearchMetrics",
      requestType = com.clarifai.grpc.api.ListAnnotationSearchMetricsRequest.class,
      responseType = com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListAnnotationSearchMetricsMethod() {
    io.grpc.MethodDescriptor getListAnnotationSearchMetricsMethod;
    if ((getListAnnotationSearchMetricsMethod = V2Grpc.getListAnnotationSearchMetricsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListAnnotationSearchMetricsMethod = V2Grpc.getListAnnotationSearchMetricsMethod) == null) {
          V2Grpc.getListAnnotationSearchMetricsMethod = getListAnnotationSearchMetricsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListAnnotationSearchMetrics"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListAnnotationSearchMetricsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListAnnotationSearchMetrics"))
              .build();
        }
      }
    }
    return getListAnnotationSearchMetricsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteAnnotationSearchMetricsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteAnnotationSearchMetrics",
      requestType = com.clarifai.grpc.api.DeleteAnnotationSearchMetricsRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteAnnotationSearchMetricsMethod() {
    io.grpc.MethodDescriptor getDeleteAnnotationSearchMetricsMethod;
    if ((getDeleteAnnotationSearchMetricsMethod = V2Grpc.getDeleteAnnotationSearchMetricsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteAnnotationSearchMetricsMethod = V2Grpc.getDeleteAnnotationSearchMetricsMethod) == null) {
          V2Grpc.getDeleteAnnotationSearchMetricsMethod = getDeleteAnnotationSearchMetricsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteAnnotationSearchMetrics"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteAnnotationSearchMetricsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteAnnotationSearchMetrics"))
              .build();
        }
      }
    }
    return getDeleteAnnotationSearchMetricsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteSearchMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteSearch",
      requestType = com.clarifai.grpc.api.DeleteSearchRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteSearchMethod() {
    io.grpc.MethodDescriptor getDeleteSearchMethod;
    if ((getDeleteSearchMethod = V2Grpc.getDeleteSearchMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteSearchMethod = V2Grpc.getDeleteSearchMethod) == null) {
          V2Grpc.getDeleteSearchMethod = getDeleteSearchMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteSearch"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteSearchRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteSearch"))
              .build();
        }
      }
    }
    return getDeleteSearchMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListStatusCodesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListStatusCodes",
      requestType = com.clarifai.grpc.api.ListStatusCodesRequest.class,
      responseType = com.clarifai.grpc.api.MultiStatusCodeResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListStatusCodesMethod() {
    io.grpc.MethodDescriptor getListStatusCodesMethod;
    if ((getListStatusCodesMethod = V2Grpc.getListStatusCodesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListStatusCodesMethod = V2Grpc.getListStatusCodesMethod) == null) {
          V2Grpc.getListStatusCodesMethod = getListStatusCodesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListStatusCodes"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListStatusCodesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiStatusCodeResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListStatusCodes"))
              .build();
        }
      }
    }
    return getListStatusCodesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetStatusCodeMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetStatusCode",
      requestType = com.clarifai.grpc.api.GetStatusCodeRequest.class,
      responseType = com.clarifai.grpc.api.SingleStatusCodeResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetStatusCodeMethod() {
    io.grpc.MethodDescriptor getGetStatusCodeMethod;
    if ((getGetStatusCodeMethod = V2Grpc.getGetStatusCodeMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetStatusCodeMethod = V2Grpc.getGetStatusCodeMethod) == null) {
          V2Grpc.getGetStatusCodeMethod = getGetStatusCodeMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetStatusCode"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetStatusCodeRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleStatusCodeResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetStatusCode"))
              .build();
        }
      }
    }
    return getGetStatusCodeMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListCollaboratorsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListCollaborators",
      requestType = com.clarifai.grpc.api.ListCollaboratorsRequest.class,
      responseType = com.clarifai.grpc.api.MultiCollaboratorsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListCollaboratorsMethod() {
    io.grpc.MethodDescriptor getListCollaboratorsMethod;
    if ((getListCollaboratorsMethod = V2Grpc.getListCollaboratorsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListCollaboratorsMethod = V2Grpc.getListCollaboratorsMethod) == null) {
          V2Grpc.getListCollaboratorsMethod = getListCollaboratorsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListCollaborators"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListCollaboratorsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiCollaboratorsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListCollaborators"))
              .build();
        }
      }
    }
    return getListCollaboratorsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostCollaboratorsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostCollaborators",
      requestType = com.clarifai.grpc.api.PostCollaboratorsRequest.class,
      responseType = com.clarifai.grpc.api.MultiCollaboratorsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostCollaboratorsMethod() {
    io.grpc.MethodDescriptor getPostCollaboratorsMethod;
    if ((getPostCollaboratorsMethod = V2Grpc.getPostCollaboratorsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostCollaboratorsMethod = V2Grpc.getPostCollaboratorsMethod) == null) {
          V2Grpc.getPostCollaboratorsMethod = getPostCollaboratorsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostCollaborators"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostCollaboratorsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiCollaboratorsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostCollaborators"))
              .build();
        }
      }
    }
    return getPostCollaboratorsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchCollaboratorsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchCollaborators",
      requestType = com.clarifai.grpc.api.PatchCollaboratorsRequest.class,
      responseType = com.clarifai.grpc.api.MultiCollaboratorsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchCollaboratorsMethod() {
    io.grpc.MethodDescriptor getPatchCollaboratorsMethod;
    if ((getPatchCollaboratorsMethod = V2Grpc.getPatchCollaboratorsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchCollaboratorsMethod = V2Grpc.getPatchCollaboratorsMethod) == null) {
          V2Grpc.getPatchCollaboratorsMethod = getPatchCollaboratorsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchCollaborators"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchCollaboratorsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiCollaboratorsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchCollaborators"))
              .build();
        }
      }
    }
    return getPatchCollaboratorsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteCollaboratorsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteCollaborators",
      requestType = com.clarifai.grpc.api.DeleteCollaboratorsRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteCollaboratorsMethod() {
    io.grpc.MethodDescriptor getDeleteCollaboratorsMethod;
    if ((getDeleteCollaboratorsMethod = V2Grpc.getDeleteCollaboratorsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteCollaboratorsMethod = V2Grpc.getDeleteCollaboratorsMethod) == null) {
          V2Grpc.getDeleteCollaboratorsMethod = getDeleteCollaboratorsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteCollaborators"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteCollaboratorsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteCollaborators"))
              .build();
        }
      }
    }
    return getDeleteCollaboratorsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListCollaborationsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListCollaborations",
      requestType = com.clarifai.grpc.api.ListCollaborationsRequest.class,
      responseType = com.clarifai.grpc.api.MultiCollaborationsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListCollaborationsMethod() {
    io.grpc.MethodDescriptor getListCollaborationsMethod;
    if ((getListCollaborationsMethod = V2Grpc.getListCollaborationsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListCollaborationsMethod = V2Grpc.getListCollaborationsMethod) == null) {
          V2Grpc.getListCollaborationsMethod = getListCollaborationsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListCollaborations"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListCollaborationsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiCollaborationsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListCollaborations"))
              .build();
        }
      }
    }
    return getListCollaborationsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostAppDuplicationsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostAppDuplications",
      requestType = com.clarifai.grpc.api.PostAppDuplicationsRequest.class,
      responseType = com.clarifai.grpc.api.MultiAppDuplicationsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostAppDuplicationsMethod() {
    io.grpc.MethodDescriptor getPostAppDuplicationsMethod;
    if ((getPostAppDuplicationsMethod = V2Grpc.getPostAppDuplicationsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostAppDuplicationsMethod = V2Grpc.getPostAppDuplicationsMethod) == null) {
          V2Grpc.getPostAppDuplicationsMethod = getPostAppDuplicationsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostAppDuplications"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostAppDuplicationsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAppDuplicationsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostAppDuplications"))
              .build();
        }
      }
    }
    return getPostAppDuplicationsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListAppDuplicationsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListAppDuplications",
      requestType = com.clarifai.grpc.api.ListAppDuplicationsRequest.class,
      responseType = com.clarifai.grpc.api.MultiAppDuplicationsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListAppDuplicationsMethod() {
    io.grpc.MethodDescriptor getListAppDuplicationsMethod;
    if ((getListAppDuplicationsMethod = V2Grpc.getListAppDuplicationsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListAppDuplicationsMethod = V2Grpc.getListAppDuplicationsMethod) == null) {
          V2Grpc.getListAppDuplicationsMethod = getListAppDuplicationsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListAppDuplications"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListAppDuplicationsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiAppDuplicationsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListAppDuplications"))
              .build();
        }
      }
    }
    return getListAppDuplicationsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetAppDuplicationMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetAppDuplication",
      requestType = com.clarifai.grpc.api.GetAppDuplicationRequest.class,
      responseType = com.clarifai.grpc.api.SingleAppDuplicationResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetAppDuplicationMethod() {
    io.grpc.MethodDescriptor getGetAppDuplicationMethod;
    if ((getGetAppDuplicationMethod = V2Grpc.getGetAppDuplicationMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetAppDuplicationMethod = V2Grpc.getGetAppDuplicationMethod) == null) {
          V2Grpc.getGetAppDuplicationMethod = getGetAppDuplicationMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAppDuplication"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetAppDuplicationRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleAppDuplicationResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetAppDuplication"))
              .build();
        }
      }
    }
    return getGetAppDuplicationMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostTasksMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostTasks",
      requestType = com.clarifai.grpc.api.PostTasksRequest.class,
      responseType = com.clarifai.grpc.api.MultiTaskResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostTasksMethod() {
    io.grpc.MethodDescriptor getPostTasksMethod;
    if ((getPostTasksMethod = V2Grpc.getPostTasksMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostTasksMethod = V2Grpc.getPostTasksMethod) == null) {
          V2Grpc.getPostTasksMethod = getPostTasksMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostTasks"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostTasksRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiTaskResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostTasks"))
              .build();
        }
      }
    }
    return getPostTasksMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetTaskAnnotationCountMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetTaskAnnotationCount",
      requestType = com.clarifai.grpc.api.GetTaskCountRequest.class,
      responseType = com.clarifai.grpc.api.SingleTaskCountResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetTaskAnnotationCountMethod() {
    io.grpc.MethodDescriptor getGetTaskAnnotationCountMethod;
    if ((getGetTaskAnnotationCountMethod = V2Grpc.getGetTaskAnnotationCountMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetTaskAnnotationCountMethod = V2Grpc.getGetTaskAnnotationCountMethod) == null) {
          V2Grpc.getGetTaskAnnotationCountMethod = getGetTaskAnnotationCountMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetTaskAnnotationCount"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetTaskCountRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleTaskCountResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetTaskAnnotationCount"))
              .build();
        }
      }
    }
    return getGetTaskAnnotationCountMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetTaskInputCountMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetTaskInputCount",
      requestType = com.clarifai.grpc.api.GetTaskCountRequest.class,
      responseType = com.clarifai.grpc.api.SingleTaskCountResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetTaskInputCountMethod() {
    io.grpc.MethodDescriptor getGetTaskInputCountMethod;
    if ((getGetTaskInputCountMethod = V2Grpc.getGetTaskInputCountMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetTaskInputCountMethod = V2Grpc.getGetTaskInputCountMethod) == null) {
          V2Grpc.getGetTaskInputCountMethod = getGetTaskInputCountMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetTaskInputCount"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetTaskCountRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleTaskCountResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetTaskInputCount"))
              .build();
        }
      }
    }
    return getGetTaskInputCountMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetTaskMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetTask",
      requestType = com.clarifai.grpc.api.GetTaskRequest.class,
      responseType = com.clarifai.grpc.api.SingleTaskResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetTaskMethod() {
    io.grpc.MethodDescriptor getGetTaskMethod;
    if ((getGetTaskMethod = V2Grpc.getGetTaskMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetTaskMethod = V2Grpc.getGetTaskMethod) == null) {
          V2Grpc.getGetTaskMethod = getGetTaskMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetTask"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetTaskRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleTaskResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetTask"))
              .build();
        }
      }
    }
    return getGetTaskMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListTasksMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListTasks",
      requestType = com.clarifai.grpc.api.ListTasksRequest.class,
      responseType = com.clarifai.grpc.api.MultiTaskResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListTasksMethod() {
    io.grpc.MethodDescriptor getListTasksMethod;
    if ((getListTasksMethod = V2Grpc.getListTasksMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListTasksMethod = V2Grpc.getListTasksMethod) == null) {
          V2Grpc.getListTasksMethod = getListTasksMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListTasks"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListTasksRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiTaskResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListTasks"))
              .build();
        }
      }
    }
    return getListTasksMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchTasksMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchTasks",
      requestType = com.clarifai.grpc.api.PatchTasksRequest.class,
      responseType = com.clarifai.grpc.api.MultiTaskResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchTasksMethod() {
    io.grpc.MethodDescriptor getPatchTasksMethod;
    if ((getPatchTasksMethod = V2Grpc.getPatchTasksMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchTasksMethod = V2Grpc.getPatchTasksMethod) == null) {
          V2Grpc.getPatchTasksMethod = getPatchTasksMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchTasks"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchTasksRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiTaskResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchTasks"))
              .build();
        }
      }
    }
    return getPatchTasksMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteTasksMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteTasks",
      requestType = com.clarifai.grpc.api.DeleteTasksRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteTasksMethod() {
    io.grpc.MethodDescriptor getDeleteTasksMethod;
    if ((getDeleteTasksMethod = V2Grpc.getDeleteTasksMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteTasksMethod = V2Grpc.getDeleteTasksMethod) == null) {
          V2Grpc.getDeleteTasksMethod = getDeleteTasksMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteTasks"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteTasksRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteTasks"))
              .build();
        }
      }
    }
    return getDeleteTasksMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostCollectorsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostCollectors",
      requestType = com.clarifai.grpc.api.PostCollectorsRequest.class,
      responseType = com.clarifai.grpc.api.MultiCollectorResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostCollectorsMethod() {
    io.grpc.MethodDescriptor getPostCollectorsMethod;
    if ((getPostCollectorsMethod = V2Grpc.getPostCollectorsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostCollectorsMethod = V2Grpc.getPostCollectorsMethod) == null) {
          V2Grpc.getPostCollectorsMethod = getPostCollectorsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostCollectors"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostCollectorsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiCollectorResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostCollectors"))
              .build();
        }
      }
    }
    return getPostCollectorsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetCollectorMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetCollector",
      requestType = com.clarifai.grpc.api.GetCollectorRequest.class,
      responseType = com.clarifai.grpc.api.SingleCollectorResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetCollectorMethod() {
    io.grpc.MethodDescriptor getGetCollectorMethod;
    if ((getGetCollectorMethod = V2Grpc.getGetCollectorMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGetCollectorMethod = V2Grpc.getGetCollectorMethod) == null) {
          V2Grpc.getGetCollectorMethod = getGetCollectorMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetCollector"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.GetCollectorRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.SingleCollectorResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("GetCollector"))
              .build();
        }
      }
    }
    return getGetCollectorMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListCollectorsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListCollectors",
      requestType = com.clarifai.grpc.api.ListCollectorsRequest.class,
      responseType = com.clarifai.grpc.api.MultiCollectorResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListCollectorsMethod() {
    io.grpc.MethodDescriptor getListCollectorsMethod;
    if ((getListCollectorsMethod = V2Grpc.getListCollectorsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListCollectorsMethod = V2Grpc.getListCollectorsMethod) == null) {
          V2Grpc.getListCollectorsMethod = getListCollectorsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListCollectors"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListCollectorsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiCollectorResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListCollectors"))
              .build();
        }
      }
    }
    return getListCollectorsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPatchCollectorsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PatchCollectors",
      requestType = com.clarifai.grpc.api.PatchCollectorsRequest.class,
      responseType = com.clarifai.grpc.api.MultiCollectorResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPatchCollectorsMethod() {
    io.grpc.MethodDescriptor getPatchCollectorsMethod;
    if ((getPatchCollectorsMethod = V2Grpc.getPatchCollectorsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPatchCollectorsMethod = V2Grpc.getPatchCollectorsMethod) == null) {
          V2Grpc.getPatchCollectorsMethod = getPatchCollectorsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PatchCollectors"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PatchCollectorsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiCollectorResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PatchCollectors"))
              .build();
        }
      }
    }
    return getPatchCollectorsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteCollectorsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteCollectors",
      requestType = com.clarifai.grpc.api.DeleteCollectorsRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteCollectorsMethod() {
    io.grpc.MethodDescriptor getDeleteCollectorsMethod;
    if ((getDeleteCollectorsMethod = V2Grpc.getDeleteCollectorsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getDeleteCollectorsMethod = V2Grpc.getDeleteCollectorsMethod) == null) {
          V2Grpc.getDeleteCollectorsMethod = getDeleteCollectorsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteCollectors"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.DeleteCollectorsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("DeleteCollectors"))
              .build();
        }
      }
    }
    return getDeleteCollectorsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostStatValuesMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostStatValues",
      requestType = com.clarifai.grpc.api.PostStatValuesRequest.class,
      responseType = com.clarifai.grpc.api.MultiStatValueResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostStatValuesMethod() {
    io.grpc.MethodDescriptor getPostStatValuesMethod;
    if ((getPostStatValuesMethod = V2Grpc.getPostStatValuesMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostStatValuesMethod = V2Grpc.getPostStatValuesMethod) == null) {
          V2Grpc.getPostStatValuesMethod = getPostStatValuesMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostStatValues"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostStatValuesRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiStatValueResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostStatValues"))
              .build();
        }
      }
    }
    return getPostStatValuesMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostStatValuesAggregateMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostStatValuesAggregate",
      requestType = com.clarifai.grpc.api.PostStatValuesAggregateRequest.class,
      responseType = com.clarifai.grpc.api.MultiStatValueAggregateResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostStatValuesAggregateMethod() {
    io.grpc.MethodDescriptor getPostStatValuesAggregateMethod;
    if ((getPostStatValuesAggregateMethod = V2Grpc.getPostStatValuesAggregateMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostStatValuesAggregateMethod = V2Grpc.getPostStatValuesAggregateMethod) == null) {
          V2Grpc.getPostStatValuesAggregateMethod = getPostStatValuesAggregateMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostStatValuesAggregate"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostStatValuesAggregateRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiStatValueAggregateResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostStatValuesAggregate"))
              .build();
        }
      }
    }
    return getPostStatValuesAggregateMethod;
  }

  private static volatile io.grpc.MethodDescriptor getPostTrendingMetricsViewMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "PostTrendingMetricsView",
      requestType = com.clarifai.grpc.api.PostTrendingMetricsViewRequest.class,
      responseType = com.clarifai.grpc.api.status.BaseResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getPostTrendingMetricsViewMethod() {
    io.grpc.MethodDescriptor getPostTrendingMetricsViewMethod;
    if ((getPostTrendingMetricsViewMethod = V2Grpc.getPostTrendingMetricsViewMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getPostTrendingMetricsViewMethod = V2Grpc.getPostTrendingMetricsViewMethod) == null) {
          V2Grpc.getPostTrendingMetricsViewMethod = getPostTrendingMetricsViewMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PostTrendingMetricsView"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.PostTrendingMetricsViewRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.status.BaseResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("PostTrendingMetricsView"))
              .build();
        }
      }
    }
    return getPostTrendingMetricsViewMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListTrendingMetricsViewsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListTrendingMetricsViews",
      requestType = com.clarifai.grpc.api.ListTrendingMetricsViewsRequest.class,
      responseType = com.clarifai.grpc.api.MultiTrendingMetricsViewResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getListTrendingMetricsViewsMethod() {
    io.grpc.MethodDescriptor getListTrendingMetricsViewsMethod;
    if ((getListTrendingMetricsViewsMethod = V2Grpc.getListTrendingMetricsViewsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getListTrendingMetricsViewsMethod = V2Grpc.getListTrendingMetricsViewsMethod) == null) {
          V2Grpc.getListTrendingMetricsViewsMethod = getListTrendingMetricsViewsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListTrendingMetricsViews"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.ListTrendingMetricsViewsRequest.getDefaultInstance()))
              .setResponseMarshaller(com.clarifai.channel.ClarifaiChannel.INSTANCE.marshaller(
                  com.clarifai.grpc.api.MultiTrendingMetricsViewResponse.getDefaultInstance()))
              .setSchemaDescriptor(new V2MethodDescriptorSupplier("ListTrendingMetricsViews"))
              .build();
        }
      }
    }
    return getListTrendingMetricsViewsMethod;
  }

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

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

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

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

    /**
     *      * List concept relations between concepts in the platform.
     * MUST be above ListConcepts so that if concept_id is empty this will still match
     * /concepts/relations to list all the concept relations in the app.
     * 
     */
    public void listConceptRelations(com.clarifai.grpc.api.ListConceptRelationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListConceptRelationsMethod(), responseObserver);
    }

    /**
     *      * Post concept relations to create relations between concepts in the platform.
     * 
     */
    public void postConceptRelations(com.clarifai.grpc.api.PostConceptRelationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostConceptRelationsMethod(), responseObserver);
    }

    /**
     *      * Post concept relations to create relations between concepts in the platform.
     * 
     */
    public void deleteConceptRelations(com.clarifai.grpc.api.DeleteConceptRelationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteConceptRelationsMethod(), responseObserver);
    }

    /**
     *      * List all the concepts with their positive and negative counts
     * 
     */
    public void getConceptCounts(com.clarifai.grpc.api.GetConceptCountsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetConceptCountsMethod(), responseObserver);
    }

    /**
     *      * Get a specific concept from an app.
     * 
     */
    public void getConcept(com.clarifai.grpc.api.GetConceptRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetConceptMethod(), responseObserver);
    }

    /**
     *      * List all the concepts.
     * 
     */
    public void listConcepts(com.clarifai.grpc.api.ListConceptsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListConceptsMethod(), responseObserver);
    }

    /**
     *      * Search over the concepts to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public void postConceptsSearches(com.clarifai.grpc.api.PostConceptsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostConceptsSearchesMethod(), responseObserver);
    }

    /**
     *      * Add a concept to an app.
     * 
     */
    public void postConcepts(com.clarifai.grpc.api.PostConceptsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostConceptsMethod(), responseObserver);
    }

    /**
     *      * Patch one or more concepts.
     * 
     */
    public void patchConcepts(com.clarifai.grpc.api.PatchConceptsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchConceptsMethod(), responseObserver);
    }

    /**
     *      * Get a specific concept from an app.
     * 
     */
    public void getConceptLanguage(com.clarifai.grpc.api.GetConceptLanguageRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetConceptLanguageMethod(), responseObserver);
    }

    /**
     *      * List the concept in all the translated languages.
     * 
     */
    public void listConceptLanguages(com.clarifai.grpc.api.ListConceptLanguagesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListConceptLanguagesMethod(), responseObserver);
    }

    /**
     *      * Add a new translation for this concept.
     * 
     */
    public void postConceptLanguages(com.clarifai.grpc.api.PostConceptLanguagesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostConceptLanguagesMethod(), responseObserver);
    }

    /**
     *      * Patch the name for a given language names by passing in a list of concepts with the new names
     * for the languages.
     * 
     */
    public void patchConceptLanguages(com.clarifai.grpc.api.PatchConceptLanguagesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchConceptLanguagesMethod(), responseObserver);
    }

    /**
     *      * List all domain graphs.
     * 
     */
    public void listKnowledgeGraphs(com.clarifai.grpc.api.ListKnowledgeGraphsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListKnowledgeGraphsMethod(), responseObserver);
    }

    /**
     *      * Post domain graphs.
     * 
     */
    public void postKnowledgeGraphs(com.clarifai.grpc.api.PostKnowledgeGraphsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostKnowledgeGraphsMethod(), responseObserver);
    }

    /**
     *      * Start concept mapping jobs.
     * 
     */
    public void postConceptMappingJobs(com.clarifai.grpc.api.PostConceptMappingJobsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostConceptMappingJobsMethod(), responseObserver);
    }

    /**
     *      * Get a specific annotation from an app.
     * 
     */
    public void getAnnotation(com.clarifai.grpc.api.GetAnnotationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetAnnotationMethod(), responseObserver);
    }

    /**
     *      * List all the annotation.
     * 
     */
    public void listAnnotations(com.clarifai.grpc.api.ListAnnotationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListAnnotationsMethod(), responseObserver);
    }

    /**
     *      * Post annotations.
     * 
     */
    public void postAnnotations(com.clarifai.grpc.api.PostAnnotationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostAnnotationsMethod(), responseObserver);
    }

    /**
     *      * Patch one or more annotations.
     * 
     */
    public void patchAnnotations(com.clarifai.grpc.api.PatchAnnotationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchAnnotationsMethod(), responseObserver);
    }

    /**
     *      * Patch annotations status by worker id and task id.
     * 
     */
    public void patchAnnotationsStatus(com.clarifai.grpc.api.PatchAnnotationsStatusRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchAnnotationsStatusMethod(), responseObserver);
    }

    /**
     *      * Delete a single annotation.
     * 
     */
    public void deleteAnnotation(com.clarifai.grpc.api.DeleteAnnotationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteAnnotationMethod(), responseObserver);
    }

    /**
     *      * Delete multiple annotations in one request.
     * 
     */
    public void deleteAnnotations(com.clarifai.grpc.api.DeleteAnnotationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteAnnotationsMethod(), responseObserver);
    }

    /**
     *      * Execute a search over annotation
     * 
     */
    public void postAnnotationsSearches(com.clarifai.grpc.api.PostAnnotationsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostAnnotationsSearchesMethod(), responseObserver);
    }

    /**
     *      * Get input count per status.
     * 
     */
    public void getInputCount(com.clarifai.grpc.api.GetInputCountRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetInputCountMethod(), responseObserver);
    }

    /**
     *      * Streams all the inputs starting from oldest assets.
     * 
     */
    public void streamInputs(com.clarifai.grpc.api.StreamInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getStreamInputsMethod(), responseObserver);
    }

    /**
     *      * Get a specific input from an app.
     * 
     */
    public void getInputSamples(com.clarifai.grpc.api.GetInputSamplesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetInputSamplesMethod(), responseObserver);
    }

    /**
     *      * Get a specific input from an app.
     * 
     */
    public void getInput(com.clarifai.grpc.api.GetInputRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetInputMethod(), responseObserver);
    }

    /**
     *      * List all the inputs.
     * 
     */
    public void listInputs(com.clarifai.grpc.api.ListInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListInputsMethod(), responseObserver);
    }

    /**
     *      * Add an input (or set of inputs) to an app.
     * This call is synchronous if the PostInputsRequest contains exactly one image input. Otherwise,
     * it is asynchronous.
     * 
     */
    public void postInputs(com.clarifai.grpc.api.PostInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostInputsMethod(), responseObserver);
    }

    /**
     *      * Patch one or more inputs.
     * 
     */
    public void patchInputs(com.clarifai.grpc.api.PatchInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchInputsMethod(), responseObserver);
    }

    /**
     *      * Delete a single input asynchronously.
     * 
     */
    public void deleteInput(com.clarifai.grpc.api.DeleteInputRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteInputMethod(), responseObserver);
    }

    /**
     *      * Delete multiple inputs in one request.
     * This call is asynchronous.
     * 
     */
    public void deleteInputs(com.clarifai.grpc.api.DeleteInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteInputsMethod(), responseObserver);
    }

    /**
     *      * Execute a search over input
     * 
     */
    public void postInputsSearches(com.clarifai.grpc.api.PostInputsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostInputsSearchesMethod(), responseObserver);
    }

    /**
     *      * Get predicted outputs from the model.
     * 
     */
    public void postModelOutputs(com.clarifai.grpc.api.PostModelOutputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostModelOutputsMethod(), responseObserver);
    }

    /**
     *      * Get a specific model type.
     * 
     */
    public void getModelType(com.clarifai.grpc.api.GetModelTypeRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetModelTypeMethod(), responseObserver);
    }

    /**
     *      * List all the supported open source licenses in the platform.
     * 
     */
    public void listOpenSourceLicenses(com.clarifai.grpc.api.ListOpenSourceLicensesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListOpenSourceLicensesMethod(), responseObserver);
    }

    /**
     *      * List all the model types available in the platform.
     * This MUST be above ListModels so that the /models/types endpoint takes precedence.
     * 
     */
    public void listModelTypes(com.clarifai.grpc.api.ListModelTypesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListModelTypesMethod(), responseObserver);
    }

    /**
     *      * Get a specific model from an app.
     * 
     */
    public void getModel(com.clarifai.grpc.api.GetModelRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetModelMethod(), responseObserver);
    }

    /**
     *      * Get a the output info for a given model_id or model_id/version_id
     * combo.
     * 
     */
    public void getModelOutputInfo(com.clarifai.grpc.api.GetModelRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetModelOutputInfoMethod(), responseObserver);
    }

    /**
     *      * List all the models.
     * 
     */
    public void listModels(com.clarifai.grpc.api.ListModelsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListModelsMethod(), responseObserver);
    }

    /**
     *      * Search over the models to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public void postModelsSearches(com.clarifai.grpc.api.PostModelsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostModelsSearchesMethod(), responseObserver);
    }

    /**
     *      * Add a models to an app.
     * 
     */
    public void postModels(com.clarifai.grpc.api.PostModelsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostModelsMethod(), responseObserver);
    }

    /**
     *      * Patch one or more models.
     * 
     */
    public void patchModels(com.clarifai.grpc.api.PatchModelsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchModelsMethod(), responseObserver);
    }

    /**
     *      * Delete a single model.
     * 
     */
    public void deleteModel(com.clarifai.grpc.api.DeleteModelRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteModelMethod(), responseObserver);
    }

    /**
     *      * Delete multiple models in one request.
     * 
     */
    public void deleteModels(com.clarifai.grpc.api.DeleteModelsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteModelsMethod(), responseObserver);
    }

    /**
     *      * Update model toolkits tags
     * 
     */
    public void patchModelToolkits(com.clarifai.grpc.api.PatchModelToolkitsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchModelToolkitsMethod(), responseObserver);
    }

    /**
     *      * Update model use_cases tags
     * 
     */
    public void patchModelUseCases(com.clarifai.grpc.api.PatchModelUseCasesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchModelUseCasesMethod(), responseObserver);
    }

    /**
     *      * Update model languages tags
     * 
     */
    public void patchModelLanguages(com.clarifai.grpc.api.PatchModelLanguagesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchModelLanguagesMethod(), responseObserver);
    }

    /**
     *      * List all the inputs.
     * 
     */
    public void listModelInputs(com.clarifai.grpc.api.ListModelInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListModelInputsMethod(), responseObserver);
    }

    /**
     *      * Get a specific model from an app.
     * 
     */
    public void getModelVersion(com.clarifai.grpc.api.GetModelVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetModelVersionMethod(), responseObserver);
    }

    /**
     *      * List all the models.
     * 
     */
    public void listModelVersions(com.clarifai.grpc.api.ListModelVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListModelVersionsMethod(), responseObserver);
    }

    /**
     *      * PostModelVersionsPublish
     * 
     */
    public void postModelVersionsPublish(com.clarifai.grpc.api.PostModelVersionsPublishRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostModelVersionsPublishMethod(), responseObserver);
    }

    /**
     *      * PostModelVersionsUnPublish
     * 
     */
    public void postModelVersionsUnPublish(com.clarifai.grpc.api.PostModelVersionsUnPublishRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostModelVersionsUnPublishMethod(), responseObserver);
    }

    /**
     *      * Create a new model version to trigger training of the model.
     * 
     */
    public void postModelVersions(com.clarifai.grpc.api.PostModelVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostModelVersionsMethod(), responseObserver);
    }

    /**
     *      * PatchModelVersions
     * 
     */
    public void patchModelVersions(com.clarifai.grpc.api.PatchModelVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchModelVersionsMethod(), responseObserver);
    }

    /**
     *      * Delete a single model.
     * 
     */
    public void deleteModelVersion(com.clarifai.grpc.api.DeleteModelVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteModelVersionMethod(), responseObserver);
    }

    /**
     *      * Get the evaluation metrics for a model version.
     * 
     */
    public void getModelVersionMetrics(com.clarifai.grpc.api.GetModelVersionMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetModelVersionMetricsMethod(), responseObserver);
    }

    /**
     *      * Run the evaluation metrics for a model version.
     * 
     */
    public void postModelVersionMetrics(com.clarifai.grpc.api.PostModelVersionMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostModelVersionMetricsMethod(), responseObserver);
    }

    /**
     *      * Lists model references tied to a particular model id.
     * 
     */
    public void listModelReferences(com.clarifai.grpc.api.ListModelReferencesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListModelReferencesMethod(), responseObserver);
    }

    /**
     *      * GetModelVersionInputExample
     * 
     */
    public void getModelVersionInputExample(com.clarifai.grpc.api.GetModelVersionInputExampleRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetModelVersionInputExampleMethod(), responseObserver);
    }

    /**
     *      * ListModelVersionInputExamples
     * 
     */
    public void listModelVersionInputExamples(com.clarifai.grpc.api.ListModelVersionInputExamplesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListModelVersionInputExamplesMethod(), responseObserver);
    }

    /**
     *      * Get a specific workflow from an app.
     * 
     */
    public void getWorkflow(com.clarifai.grpc.api.GetWorkflowRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetWorkflowMethod(), responseObserver);
    }

    /**
     *      * List all the workflows.
     * 
     */
    public void listWorkflows(com.clarifai.grpc.api.ListWorkflowsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListWorkflowsMethod(), responseObserver);
    }

    /**
     *      * Add a workflow to an app.
     * 
     */
    public void postWorkflows(com.clarifai.grpc.api.PostWorkflowsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostWorkflowsMethod(), responseObserver);
    }

    /**
     *      * Patch one or more workflows.
     * 
     */
    public void patchWorkflows(com.clarifai.grpc.api.PatchWorkflowsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchWorkflowsMethod(), responseObserver);
    }

    /**
     *      * Delete a single workflow.
     * 
     */
    public void deleteWorkflow(com.clarifai.grpc.api.DeleteWorkflowRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteWorkflowMethod(), responseObserver);
    }

    /**
     *      * Delete multiple workflows in one request.
     * 
     */
    public void deleteWorkflows(com.clarifai.grpc.api.DeleteWorkflowsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteWorkflowsMethod(), responseObserver);
    }

    /**
     *      * Predict using a workflow.
     * 
     */
    public void postWorkflowResults(com.clarifai.grpc.api.PostWorkflowResultsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostWorkflowResultsMethod(), responseObserver);
    }

    /**
     *      * Compare embeddings distances using a workflow
     * 
     */
    public void postWorkflowResultsSimilarity(com.clarifai.grpc.api.PostWorkflowResultsSimilarityRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostWorkflowResultsSimilarityMethod(), responseObserver);
    }

    /**
     *      * List workflow versions.
     * 
     */
    public void listWorkflowVersions(com.clarifai.grpc.api.ListWorkflowVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListWorkflowVersionsMethod(), responseObserver);
    }

    /**
     *      * Get single workflow version.
     * 
     */
    public void getWorkflowVersion(com.clarifai.grpc.api.GetWorkflowVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetWorkflowVersionMethod(), responseObserver);
    }

    /**
     *      * Delete workflow versions.
     * 
     */
    public void deleteWorkflowVersions(com.clarifai.grpc.api.DeleteWorkflowVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteWorkflowVersionsMethod(), responseObserver);
    }

    /**
     *      * Patch workflow versions.
     * 
     */
    public void patchWorkflowVersions(com.clarifai.grpc.api.PatchWorkflowVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchWorkflowVersionsMethod(), responseObserver);
    }

    /**
     *      * Get a specific key from an app.
     * 
     */
    public void getKey(com.clarifai.grpc.api.GetKeyRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetKeyMethod(), responseObserver);
    }

    /**
     *      * List all the keys.
     * 
     */
    public void listKeys(com.clarifai.grpc.api.ListKeysRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListKeysMethod(), responseObserver);
    }

    /**
     *      * List keys by app_id
     * 
     */
    public void listAppKeys(com.clarifai.grpc.api.ListAppKeysRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListAppKeysMethod(), responseObserver);
    }

    /**
     *      * Search over the keys to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public void deleteKey(com.clarifai.grpc.api.DeleteKeyRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteKeyMethod(), responseObserver);
    }

    /**
     *      * Add a key to an app.
     * 
     */
    public void postKeys(com.clarifai.grpc.api.PostKeysRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostKeysMethod(), responseObserver);
    }

    /**
     *      * Patch one or more keys.
     * 
     */
    public void patchKeys(com.clarifai.grpc.api.PatchKeysRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchKeysMethod(), responseObserver);
    }

    /**
     *      * API Keys in the public API -- request is itself Key authorized, and will tell
     * the user the scopes/access of the key/credential they're providing, as computed by
     * our authorizer:
     * 
     */
    public void myScopes(com.clarifai.grpc.api.MyScopesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getMyScopesMethod(), responseObserver);
    }

    /**
     */
    public void myScopesUser(com.clarifai.grpc.api.MyScopesUserRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getMyScopesUserMethod(), responseObserver);
    }

    /**
     */
    public void myScopesRoot(com.clarifai.grpc.api.MyScopesRootRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getMyScopesRootMethod(), responseObserver);
    }

    /**
     *      * List all auth scopes available to me as a user.
     * 
     */
    public void listScopes(com.clarifai.grpc.api.ListScopesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListScopesMethod(), responseObserver);
    }

    /**
     *      * Get a specific app from an app.
     * 
     */
    public void getApp(com.clarifai.grpc.api.GetAppRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetAppMethod(), responseObserver);
    }

    /**
     *      * List all the apps.
     * 
     */
    public void listApps(com.clarifai.grpc.api.ListAppsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListAppsMethod(), responseObserver);
    }

    /**
     *      * Search over the apps to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public void deleteApp(com.clarifai.grpc.api.DeleteAppRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteAppMethod(), responseObserver);
    }

    /**
     *      * Add a app to an app.
     * This needs to load the default workflow to make a copy, validating all the models in it, and
     * then writing the new workflow back to this new app.
     * 
     */
    public void postApps(com.clarifai.grpc.api.PostAppsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostAppsMethod(), responseObserver);
    }

    /**
     *      * Patch one or more apps.
     * 
     */
    public void patchApps(com.clarifai.grpc.api.PatchAppsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchAppsMethod(), responseObserver);
    }

    /**
     *      * Search over the applications to find one or more you're looking for.
     * 
     */
    public void postAppsSearches(com.clarifai.grpc.api.PostAppsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostAppsSearchesMethod(), responseObserver);
    }

    /**
     *      * Validate new password in real-time for a user
     * 
     */
    public void postValidatePassword(com.clarifai.grpc.api.PostValidatePasswordRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostValidatePasswordMethod(), responseObserver);
    }

    /**
     *      * Get a saved search.
     * 
     */
    public void getSearch(com.clarifai.grpc.api.GetSearchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetSearchMethod(), responseObserver);
    }

    /**
     *      * List all saved searches.
     * 
     */
    public void listSearches(com.clarifai.grpc.api.ListSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListSearchesMethod(), responseObserver);
    }

    /**
     *      * Execute a new search and optionally save it.
     * 
     */
    public void postSearches(com.clarifai.grpc.api.PostSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostSearchesMethod(), responseObserver);
    }

    /**
     *      * Execute a previously saved search.
     * 
     */
    public void postSearchesByID(com.clarifai.grpc.api.PostSearchesByIDRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostSearchesByIDMethod(), responseObserver);
    }

    /**
     *      * Evaluate the results of two search requests
     * 
     */
    public void postAnnotationSearchMetrics(com.clarifai.grpc.api.PostAnnotationSearchMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostAnnotationSearchMetricsMethod(), responseObserver);
    }

    /**
     *      * Get the evaluation results between two search requests
     * 
     */
    public void getAnnotationSearchMetrics(com.clarifai.grpc.api.GetAnnotationSearchMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetAnnotationSearchMetricsMethod(), responseObserver);
    }

    /**
     *      * List the evaluation results between two search requests
     * 
     */
    public void listAnnotationSearchMetrics(com.clarifai.grpc.api.ListAnnotationSearchMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListAnnotationSearchMetricsMethod(), responseObserver);
    }

    /**
     *      * DeleteAnnotationSearchMetrics
     * 
     */
    public void deleteAnnotationSearchMetrics(com.clarifai.grpc.api.DeleteAnnotationSearchMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteAnnotationSearchMetricsMethod(), responseObserver);
    }

    /**
     *      * Delete a saved search.
     * 
     */
    public void deleteSearch(com.clarifai.grpc.api.DeleteSearchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteSearchMethod(), responseObserver);
    }

    /**
     *      * List all status codes.
     * 
     */
    public void listStatusCodes(com.clarifai.grpc.api.ListStatusCodesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListStatusCodesMethod(), responseObserver);
    }

    /**
     *      * Get more details for a status code.
     * 
     */
    public void getStatusCode(com.clarifai.grpc.api.GetStatusCodeRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetStatusCodeMethod(), responseObserver);
    }

    /**
     *      * owner list users who the app is shared with
     * 
     */
    public void listCollaborators(com.clarifai.grpc.api.ListCollaboratorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListCollaboratorsMethod(), responseObserver);
    }

    /**
     *      * add collaborators to an app.
     * 
     */
    public void postCollaborators(com.clarifai.grpc.api.PostCollaboratorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostCollaboratorsMethod(), responseObserver);
    }

    /**
     *      * Patch existing collaborators.
     * 
     */
    public void patchCollaborators(com.clarifai.grpc.api.PatchCollaboratorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchCollaboratorsMethod(), responseObserver);
    }

    /**
     *      * Delete existing collaborators.
     * 
     */
    public void deleteCollaborators(com.clarifai.grpc.api.DeleteCollaboratorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteCollaboratorsMethod(), responseObserver);
    }

    /**
     *      * Collaboration includes the app user are invitied to work on
     * 
     */
    public void listCollaborations(com.clarifai.grpc.api.ListCollaborationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListCollaborationsMethod(), responseObserver);
    }

    /**
     *      * start to duplicate an app which copies all the inputs, annotations, models, concepts etc. to a new app.
     * this is an async process, you should use ListAppDuplications or GetAppDuplication to check the status.
     * 
     */
    public void postAppDuplications(com.clarifai.grpc.api.PostAppDuplicationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostAppDuplicationsMethod(), responseObserver);
    }

    /**
     *      * list all the app duplications user triggers
     * 
     */
    public void listAppDuplications(com.clarifai.grpc.api.ListAppDuplicationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListAppDuplicationsMethod(), responseObserver);
    }

    /**
     *      * get the app duplication status
     * 
     */
    public void getAppDuplication(com.clarifai.grpc.api.GetAppDuplicationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetAppDuplicationMethod(), responseObserver);
    }

    /**
     *      * Add tasks to an app.
     * 
     */
    public void postTasks(com.clarifai.grpc.api.PostTasksRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostTasksMethod(), responseObserver);
    }

    /**
     *      * Task annotation count
     * 
     */
    public void getTaskAnnotationCount(com.clarifai.grpc.api.GetTaskCountRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetTaskAnnotationCountMethod(), responseObserver);
    }

    /**
     *      * Task Input count
     * 
     */
    public void getTaskInputCount(com.clarifai.grpc.api.GetTaskCountRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetTaskInputCountMethod(), responseObserver);
    }

    /**
     *      * Get a specific task from an app.
     * 
     */
    public void getTask(com.clarifai.grpc.api.GetTaskRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetTaskMethod(), responseObserver);
    }

    /**
     *      * List tasks from an app.
     * 
     */
    public void listTasks(com.clarifai.grpc.api.ListTasksRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListTasksMethod(), responseObserver);
    }

    /**
     *      * Patch one or more tasks.
     * 
     */
    public void patchTasks(com.clarifai.grpc.api.PatchTasksRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchTasksMethod(), responseObserver);
    }

    /**
     *      * Delete multiple tasks in one request.
     * 
     */
    public void deleteTasks(com.clarifai.grpc.api.DeleteTasksRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteTasksMethod(), responseObserver);
    }

    /**
     *      * Add a list of Collectors to an app.
     * In the handler of this endpoint we also check for all the scopes of the  POST /inputs
     * endpoint.
     * Those current scopes are listed here as a hard requirement.
     * They are needed when adding the collectors just so we now that you have permission with
     * that key at least to do the writing to this app with POST /inputs.
     * 
     */
    public void postCollectors(com.clarifai.grpc.api.PostCollectorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostCollectorsMethod(), responseObserver);
    }

    /**
     *      * Get a specific collector from an app.
     * 
     */
    public void getCollector(com.clarifai.grpc.api.GetCollectorRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getGetCollectorMethod(), responseObserver);
    }

    /**
     *      * List all the collectors.
     * 
     */
    public void listCollectors(com.clarifai.grpc.api.ListCollectorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListCollectorsMethod(), responseObserver);
    }

    /**
     *      * Patch one or more collectors.
     * 
     */
    public void patchCollectors(com.clarifai.grpc.api.PatchCollectorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPatchCollectorsMethod(), responseObserver);
    }

    /**
     *      * Delete multiple collectors in one request.
     * This call is asynchronous. Use DeleteCollector if you want a synchronous version.
     * 
     */
    public void deleteCollectors(com.clarifai.grpc.api.DeleteCollectorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getDeleteCollectorsMethod(), responseObserver);
    }

    /**
     *      * PostStatValues
     * 
     */
    public void postStatValues(com.clarifai.grpc.api.PostStatValuesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostStatValuesMethod(), responseObserver);
    }

    /**
     *      * PostStatValuesAggregate
     * 
     */
    public void postStatValuesAggregate(com.clarifai.grpc.api.PostStatValuesAggregateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostStatValuesAggregateMethod(), responseObserver);
    }

    /**
     *      * Increase the view metric for a detail view
     * 
     */
    public void postTrendingMetricsView(com.clarifai.grpc.api.PostTrendingMetricsViewRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getPostTrendingMetricsViewMethod(), responseObserver);
    }

    /**
     *      * List the view metrics for a detail view
     * 
     */
    public void listTrendingMetricsViews(com.clarifai.grpc.api.ListTrendingMetricsViewsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnimplementedUnaryCall(getListTrendingMetricsViewsMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getListConceptRelationsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListConceptRelationsRequest,
                com.clarifai.grpc.api.MultiConceptRelationResponse>(
                  this, METHODID_LIST_CONCEPT_RELATIONS)))
          .addMethod(
            getPostConceptRelationsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostConceptRelationsRequest,
                com.clarifai.grpc.api.MultiConceptRelationResponse>(
                  this, METHODID_POST_CONCEPT_RELATIONS)))
          .addMethod(
            getDeleteConceptRelationsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteConceptRelationsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_CONCEPT_RELATIONS)))
          .addMethod(
            getGetConceptCountsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetConceptCountsRequest,
                com.clarifai.grpc.api.MultiConceptCountResponse>(
                  this, METHODID_GET_CONCEPT_COUNTS)))
          .addMethod(
            getGetConceptMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetConceptRequest,
                com.clarifai.grpc.api.SingleConceptResponse>(
                  this, METHODID_GET_CONCEPT)))
          .addMethod(
            getListConceptsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListConceptsRequest,
                com.clarifai.grpc.api.MultiConceptResponse>(
                  this, METHODID_LIST_CONCEPTS)))
          .addMethod(
            getPostConceptsSearchesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostConceptsSearchesRequest,
                com.clarifai.grpc.api.MultiConceptResponse>(
                  this, METHODID_POST_CONCEPTS_SEARCHES)))
          .addMethod(
            getPostConceptsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostConceptsRequest,
                com.clarifai.grpc.api.MultiConceptResponse>(
                  this, METHODID_POST_CONCEPTS)))
          .addMethod(
            getPatchConceptsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchConceptsRequest,
                com.clarifai.grpc.api.MultiConceptResponse>(
                  this, METHODID_PATCH_CONCEPTS)))
          .addMethod(
            getGetConceptLanguageMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetConceptLanguageRequest,
                com.clarifai.grpc.api.SingleConceptLanguageResponse>(
                  this, METHODID_GET_CONCEPT_LANGUAGE)))
          .addMethod(
            getListConceptLanguagesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListConceptLanguagesRequest,
                com.clarifai.grpc.api.MultiConceptLanguageResponse>(
                  this, METHODID_LIST_CONCEPT_LANGUAGES)))
          .addMethod(
            getPostConceptLanguagesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostConceptLanguagesRequest,
                com.clarifai.grpc.api.MultiConceptLanguageResponse>(
                  this, METHODID_POST_CONCEPT_LANGUAGES)))
          .addMethod(
            getPatchConceptLanguagesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchConceptLanguagesRequest,
                com.clarifai.grpc.api.MultiConceptLanguageResponse>(
                  this, METHODID_PATCH_CONCEPT_LANGUAGES)))
          .addMethod(
            getListKnowledgeGraphsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListKnowledgeGraphsRequest,
                com.clarifai.grpc.api.MultiKnowledgeGraphResponse>(
                  this, METHODID_LIST_KNOWLEDGE_GRAPHS)))
          .addMethod(
            getPostKnowledgeGraphsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostKnowledgeGraphsRequest,
                com.clarifai.grpc.api.MultiKnowledgeGraphResponse>(
                  this, METHODID_POST_KNOWLEDGE_GRAPHS)))
          .addMethod(
            getPostConceptMappingJobsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostConceptMappingJobsRequest,
                com.clarifai.grpc.api.MultiConceptMappingJobResponse>(
                  this, METHODID_POST_CONCEPT_MAPPING_JOBS)))
          .addMethod(
            getGetAnnotationMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetAnnotationRequest,
                com.clarifai.grpc.api.SingleAnnotationResponse>(
                  this, METHODID_GET_ANNOTATION)))
          .addMethod(
            getListAnnotationsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAnnotationsRequest,
                com.clarifai.grpc.api.MultiAnnotationResponse>(
                  this, METHODID_LIST_ANNOTATIONS)))
          .addMethod(
            getPostAnnotationsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAnnotationsRequest,
                com.clarifai.grpc.api.MultiAnnotationResponse>(
                  this, METHODID_POST_ANNOTATIONS)))
          .addMethod(
            getPatchAnnotationsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchAnnotationsRequest,
                com.clarifai.grpc.api.MultiAnnotationResponse>(
                  this, METHODID_PATCH_ANNOTATIONS)))
          .addMethod(
            getPatchAnnotationsStatusMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchAnnotationsStatusRequest,
                com.clarifai.grpc.api.PatchAnnotationsStatusResponse>(
                  this, METHODID_PATCH_ANNOTATIONS_STATUS)))
          .addMethod(
            getDeleteAnnotationMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteAnnotationRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_ANNOTATION)))
          .addMethod(
            getDeleteAnnotationsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteAnnotationsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_ANNOTATIONS)))
          .addMethod(
            getPostAnnotationsSearchesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAnnotationsSearchesRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_POST_ANNOTATIONS_SEARCHES)))
          .addMethod(
            getGetInputCountMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetInputCountRequest,
                com.clarifai.grpc.api.SingleInputCountResponse>(
                  this, METHODID_GET_INPUT_COUNT)))
          .addMethod(
            getStreamInputsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.StreamInputsRequest,
                com.clarifai.grpc.api.MultiInputResponse>(
                  this, METHODID_STREAM_INPUTS)))
          .addMethod(
            getGetInputSamplesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetInputSamplesRequest,
                com.clarifai.grpc.api.MultiInputAnnotationResponse>(
                  this, METHODID_GET_INPUT_SAMPLES)))
          .addMethod(
            getGetInputMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetInputRequest,
                com.clarifai.grpc.api.SingleInputResponse>(
                  this, METHODID_GET_INPUT)))
          .addMethod(
            getListInputsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListInputsRequest,
                com.clarifai.grpc.api.MultiInputResponse>(
                  this, METHODID_LIST_INPUTS)))
          .addMethod(
            getPostInputsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostInputsRequest,
                com.clarifai.grpc.api.MultiInputResponse>(
                  this, METHODID_POST_INPUTS)))
          .addMethod(
            getPatchInputsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchInputsRequest,
                com.clarifai.grpc.api.MultiInputResponse>(
                  this, METHODID_PATCH_INPUTS)))
          .addMethod(
            getDeleteInputMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteInputRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_INPUT)))
          .addMethod(
            getDeleteInputsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteInputsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_INPUTS)))
          .addMethod(
            getPostInputsSearchesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostInputsSearchesRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_POST_INPUTS_SEARCHES)))
          .addMethod(
            getPostModelOutputsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelOutputsRequest,
                com.clarifai.grpc.api.MultiOutputResponse>(
                  this, METHODID_POST_MODEL_OUTPUTS)))
          .addMethod(
            getGetModelTypeMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelTypeRequest,
                com.clarifai.grpc.api.SingleModelTypeResponse>(
                  this, METHODID_GET_MODEL_TYPE)))
          .addMethod(
            getListOpenSourceLicensesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListOpenSourceLicensesRequest,
                com.clarifai.grpc.api.ListOpenSourceLicensesResponse>(
                  this, METHODID_LIST_OPEN_SOURCE_LICENSES)))
          .addMethod(
            getListModelTypesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelTypesRequest,
                com.clarifai.grpc.api.MultiModelTypeResponse>(
                  this, METHODID_LIST_MODEL_TYPES)))
          .addMethod(
            getGetModelMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelRequest,
                com.clarifai.grpc.api.SingleModelResponse>(
                  this, METHODID_GET_MODEL)))
          .addMethod(
            getGetModelOutputInfoMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelRequest,
                com.clarifai.grpc.api.SingleModelResponse>(
                  this, METHODID_GET_MODEL_OUTPUT_INFO)))
          .addMethod(
            getListModelsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelsRequest,
                com.clarifai.grpc.api.MultiModelResponse>(
                  this, METHODID_LIST_MODELS)))
          .addMethod(
            getPostModelsSearchesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelsSearchesRequest,
                com.clarifai.grpc.api.MultiModelResponse>(
                  this, METHODID_POST_MODELS_SEARCHES)))
          .addMethod(
            getPostModelsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelsRequest,
                com.clarifai.grpc.api.SingleModelResponse>(
                  this, METHODID_POST_MODELS)))
          .addMethod(
            getPatchModelsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelsRequest,
                com.clarifai.grpc.api.MultiModelResponse>(
                  this, METHODID_PATCH_MODELS)))
          .addMethod(
            getDeleteModelMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteModelRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_MODEL)))
          .addMethod(
            getDeleteModelsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteModelsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_MODELS)))
          .addMethod(
            getPatchModelToolkitsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelToolkitsRequest,
                com.clarifai.grpc.api.MultiModelToolkitResponse>(
                  this, METHODID_PATCH_MODEL_TOOLKITS)))
          .addMethod(
            getPatchModelUseCasesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelUseCasesRequest,
                com.clarifai.grpc.api.MultiModelUseCaseResponse>(
                  this, METHODID_PATCH_MODEL_USE_CASES)))
          .addMethod(
            getPatchModelLanguagesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelLanguagesRequest,
                com.clarifai.grpc.api.MultiModelLanguageResponse>(
                  this, METHODID_PATCH_MODEL_LANGUAGES)))
          .addMethod(
            getListModelInputsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelInputsRequest,
                com.clarifai.grpc.api.MultiInputResponse>(
                  this, METHODID_LIST_MODEL_INPUTS)))
          .addMethod(
            getGetModelVersionMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelVersionRequest,
                com.clarifai.grpc.api.SingleModelVersionResponse>(
                  this, METHODID_GET_MODEL_VERSION)))
          .addMethod(
            getListModelVersionsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelVersionsRequest,
                com.clarifai.grpc.api.MultiModelVersionResponse>(
                  this, METHODID_LIST_MODEL_VERSIONS)))
          .addMethod(
            getPostModelVersionsPublishMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelVersionsPublishRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_POST_MODEL_VERSIONS_PUBLISH)))
          .addMethod(
            getPostModelVersionsUnPublishMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelVersionsUnPublishRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_POST_MODEL_VERSIONS_UN_PUBLISH)))
          .addMethod(
            getPostModelVersionsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelVersionsRequest,
                com.clarifai.grpc.api.SingleModelResponse>(
                  this, METHODID_POST_MODEL_VERSIONS)))
          .addMethod(
            getPatchModelVersionsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelVersionsRequest,
                com.clarifai.grpc.api.MultiModelVersionResponse>(
                  this, METHODID_PATCH_MODEL_VERSIONS)))
          .addMethod(
            getDeleteModelVersionMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteModelVersionRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_MODEL_VERSION)))
          .addMethod(
            getGetModelVersionMetricsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelVersionMetricsRequest,
                com.clarifai.grpc.api.SingleModelVersionResponse>(
                  this, METHODID_GET_MODEL_VERSION_METRICS)))
          .addMethod(
            getPostModelVersionMetricsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelVersionMetricsRequest,
                com.clarifai.grpc.api.SingleModelVersionResponse>(
                  this, METHODID_POST_MODEL_VERSION_METRICS)))
          .addMethod(
            getListModelReferencesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelReferencesRequest,
                com.clarifai.grpc.api.MultiModelReferenceResponse>(
                  this, METHODID_LIST_MODEL_REFERENCES)))
          .addMethod(
            getGetModelVersionInputExampleMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelVersionInputExampleRequest,
                com.clarifai.grpc.api.SingleModelVersionInputExampleResponse>(
                  this, METHODID_GET_MODEL_VERSION_INPUT_EXAMPLE)))
          .addMethod(
            getListModelVersionInputExamplesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelVersionInputExamplesRequest,
                com.clarifai.grpc.api.MultiModelVersionInputExampleResponse>(
                  this, METHODID_LIST_MODEL_VERSION_INPUT_EXAMPLES)))
          .addMethod(
            getGetWorkflowMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetWorkflowRequest,
                com.clarifai.grpc.api.SingleWorkflowResponse>(
                  this, METHODID_GET_WORKFLOW)))
          .addMethod(
            getListWorkflowsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListWorkflowsRequest,
                com.clarifai.grpc.api.MultiWorkflowResponse>(
                  this, METHODID_LIST_WORKFLOWS)))
          .addMethod(
            getPostWorkflowsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostWorkflowsRequest,
                com.clarifai.grpc.api.MultiWorkflowResponse>(
                  this, METHODID_POST_WORKFLOWS)))
          .addMethod(
            getPatchWorkflowsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchWorkflowsRequest,
                com.clarifai.grpc.api.MultiWorkflowResponse>(
                  this, METHODID_PATCH_WORKFLOWS)))
          .addMethod(
            getDeleteWorkflowMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteWorkflowRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_WORKFLOW)))
          .addMethod(
            getDeleteWorkflowsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteWorkflowsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_WORKFLOWS)))
          .addMethod(
            getPostWorkflowResultsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostWorkflowResultsRequest,
                com.clarifai.grpc.api.PostWorkflowResultsResponse>(
                  this, METHODID_POST_WORKFLOW_RESULTS)))
          .addMethod(
            getPostWorkflowResultsSimilarityMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostWorkflowResultsSimilarityRequest,
                com.clarifai.grpc.api.PostWorkflowResultsSimilarityResponse>(
                  this, METHODID_POST_WORKFLOW_RESULTS_SIMILARITY)))
          .addMethod(
            getListWorkflowVersionsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListWorkflowVersionsRequest,
                com.clarifai.grpc.api.MultiWorkflowVersionResponse>(
                  this, METHODID_LIST_WORKFLOW_VERSIONS)))
          .addMethod(
            getGetWorkflowVersionMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetWorkflowVersionRequest,
                com.clarifai.grpc.api.SingleWorkflowVersionResponse>(
                  this, METHODID_GET_WORKFLOW_VERSION)))
          .addMethod(
            getDeleteWorkflowVersionsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteWorkflowVersionsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_WORKFLOW_VERSIONS)))
          .addMethod(
            getPatchWorkflowVersionsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchWorkflowVersionsRequest,
                com.clarifai.grpc.api.MultiWorkflowVersionResponse>(
                  this, METHODID_PATCH_WORKFLOW_VERSIONS)))
          .addMethod(
            getGetKeyMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetKeyRequest,
                com.clarifai.grpc.api.SingleKeyResponse>(
                  this, METHODID_GET_KEY)))
          .addMethod(
            getListKeysMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListKeysRequest,
                com.clarifai.grpc.api.MultiKeyResponse>(
                  this, METHODID_LIST_KEYS)))
          .addMethod(
            getListAppKeysMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAppKeysRequest,
                com.clarifai.grpc.api.MultiKeyResponse>(
                  this, METHODID_LIST_APP_KEYS)))
          .addMethod(
            getDeleteKeyMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteKeyRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_KEY)))
          .addMethod(
            getPostKeysMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostKeysRequest,
                com.clarifai.grpc.api.MultiKeyResponse>(
                  this, METHODID_POST_KEYS)))
          .addMethod(
            getPatchKeysMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchKeysRequest,
                com.clarifai.grpc.api.MultiKeyResponse>(
                  this, METHODID_PATCH_KEYS)))
          .addMethod(
            getMyScopesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.MyScopesRequest,
                com.clarifai.grpc.api.MultiScopeResponse>(
                  this, METHODID_MY_SCOPES)))
          .addMethod(
            getMyScopesUserMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.MyScopesUserRequest,
                com.clarifai.grpc.api.MultiScopeUserResponse>(
                  this, METHODID_MY_SCOPES_USER)))
          .addMethod(
            getMyScopesRootMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.MyScopesRootRequest,
                com.clarifai.grpc.api.MultiScopeRootResponse>(
                  this, METHODID_MY_SCOPES_ROOT)))
          .addMethod(
            getListScopesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListScopesRequest,
                com.clarifai.grpc.api.MultiScopeDepsResponse>(
                  this, METHODID_LIST_SCOPES)))
          .addMethod(
            getGetAppMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetAppRequest,
                com.clarifai.grpc.api.SingleAppResponse>(
                  this, METHODID_GET_APP)))
          .addMethod(
            getListAppsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAppsRequest,
                com.clarifai.grpc.api.MultiAppResponse>(
                  this, METHODID_LIST_APPS)))
          .addMethod(
            getDeleteAppMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteAppRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_APP)))
          .addMethod(
            getPostAppsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAppsRequest,
                com.clarifai.grpc.api.MultiAppResponse>(
                  this, METHODID_POST_APPS)))
          .addMethod(
            getPatchAppsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchAppsRequest,
                com.clarifai.grpc.api.MultiAppResponse>(
                  this, METHODID_PATCH_APPS)))
          .addMethod(
            getPostAppsSearchesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAppsSearchesRequest,
                com.clarifai.grpc.api.MultiAppResponse>(
                  this, METHODID_POST_APPS_SEARCHES)))
          .addMethod(
            getPostValidatePasswordMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostValidatePasswordRequest,
                com.clarifai.grpc.api.SinglePasswordValidationResponse>(
                  this, METHODID_POST_VALIDATE_PASSWORD)))
          .addMethod(
            getGetSearchMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetSearchRequest,
                com.clarifai.grpc.api.SingleSearchResponse>(
                  this, METHODID_GET_SEARCH)))
          .addMethod(
            getListSearchesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListSearchesRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_LIST_SEARCHES)))
          .addMethod(
            getPostSearchesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostSearchesRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_POST_SEARCHES)))
          .addMethod(
            getPostSearchesByIDMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostSearchesByIDRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_POST_SEARCHES_BY_ID)))
          .addMethod(
            getPostAnnotationSearchMetricsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAnnotationSearchMetricsRequest,
                com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse>(
                  this, METHODID_POST_ANNOTATION_SEARCH_METRICS)))
          .addMethod(
            getGetAnnotationSearchMetricsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetAnnotationSearchMetricsRequest,
                com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse>(
                  this, METHODID_GET_ANNOTATION_SEARCH_METRICS)))
          .addMethod(
            getListAnnotationSearchMetricsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAnnotationSearchMetricsRequest,
                com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse>(
                  this, METHODID_LIST_ANNOTATION_SEARCH_METRICS)))
          .addMethod(
            getDeleteAnnotationSearchMetricsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteAnnotationSearchMetricsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_ANNOTATION_SEARCH_METRICS)))
          .addMethod(
            getDeleteSearchMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteSearchRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_SEARCH)))
          .addMethod(
            getListStatusCodesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListStatusCodesRequest,
                com.clarifai.grpc.api.MultiStatusCodeResponse>(
                  this, METHODID_LIST_STATUS_CODES)))
          .addMethod(
            getGetStatusCodeMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetStatusCodeRequest,
                com.clarifai.grpc.api.SingleStatusCodeResponse>(
                  this, METHODID_GET_STATUS_CODE)))
          .addMethod(
            getListCollaboratorsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListCollaboratorsRequest,
                com.clarifai.grpc.api.MultiCollaboratorsResponse>(
                  this, METHODID_LIST_COLLABORATORS)))
          .addMethod(
            getPostCollaboratorsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostCollaboratorsRequest,
                com.clarifai.grpc.api.MultiCollaboratorsResponse>(
                  this, METHODID_POST_COLLABORATORS)))
          .addMethod(
            getPatchCollaboratorsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchCollaboratorsRequest,
                com.clarifai.grpc.api.MultiCollaboratorsResponse>(
                  this, METHODID_PATCH_COLLABORATORS)))
          .addMethod(
            getDeleteCollaboratorsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteCollaboratorsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_COLLABORATORS)))
          .addMethod(
            getListCollaborationsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListCollaborationsRequest,
                com.clarifai.grpc.api.MultiCollaborationsResponse>(
                  this, METHODID_LIST_COLLABORATIONS)))
          .addMethod(
            getPostAppDuplicationsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAppDuplicationsRequest,
                com.clarifai.grpc.api.MultiAppDuplicationsResponse>(
                  this, METHODID_POST_APP_DUPLICATIONS)))
          .addMethod(
            getListAppDuplicationsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAppDuplicationsRequest,
                com.clarifai.grpc.api.MultiAppDuplicationsResponse>(
                  this, METHODID_LIST_APP_DUPLICATIONS)))
          .addMethod(
            getGetAppDuplicationMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetAppDuplicationRequest,
                com.clarifai.grpc.api.SingleAppDuplicationResponse>(
                  this, METHODID_GET_APP_DUPLICATION)))
          .addMethod(
            getPostTasksMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostTasksRequest,
                com.clarifai.grpc.api.MultiTaskResponse>(
                  this, METHODID_POST_TASKS)))
          .addMethod(
            getGetTaskAnnotationCountMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetTaskCountRequest,
                com.clarifai.grpc.api.SingleTaskCountResponse>(
                  this, METHODID_GET_TASK_ANNOTATION_COUNT)))
          .addMethod(
            getGetTaskInputCountMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetTaskCountRequest,
                com.clarifai.grpc.api.SingleTaskCountResponse>(
                  this, METHODID_GET_TASK_INPUT_COUNT)))
          .addMethod(
            getGetTaskMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetTaskRequest,
                com.clarifai.grpc.api.SingleTaskResponse>(
                  this, METHODID_GET_TASK)))
          .addMethod(
            getListTasksMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListTasksRequest,
                com.clarifai.grpc.api.MultiTaskResponse>(
                  this, METHODID_LIST_TASKS)))
          .addMethod(
            getPatchTasksMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchTasksRequest,
                com.clarifai.grpc.api.MultiTaskResponse>(
                  this, METHODID_PATCH_TASKS)))
          .addMethod(
            getDeleteTasksMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteTasksRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_TASKS)))
          .addMethod(
            getPostCollectorsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostCollectorsRequest,
                com.clarifai.grpc.api.MultiCollectorResponse>(
                  this, METHODID_POST_COLLECTORS)))
          .addMethod(
            getGetCollectorMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetCollectorRequest,
                com.clarifai.grpc.api.SingleCollectorResponse>(
                  this, METHODID_GET_COLLECTOR)))
          .addMethod(
            getListCollectorsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListCollectorsRequest,
                com.clarifai.grpc.api.MultiCollectorResponse>(
                  this, METHODID_LIST_COLLECTORS)))
          .addMethod(
            getPatchCollectorsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchCollectorsRequest,
                com.clarifai.grpc.api.MultiCollectorResponse>(
                  this, METHODID_PATCH_COLLECTORS)))
          .addMethod(
            getDeleteCollectorsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteCollectorsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_COLLECTORS)))
          .addMethod(
            getPostStatValuesMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostStatValuesRequest,
                com.clarifai.grpc.api.MultiStatValueResponse>(
                  this, METHODID_POST_STAT_VALUES)))
          .addMethod(
            getPostStatValuesAggregateMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostStatValuesAggregateRequest,
                com.clarifai.grpc.api.MultiStatValueAggregateResponse>(
                  this, METHODID_POST_STAT_VALUES_AGGREGATE)))
          .addMethod(
            getPostTrendingMetricsViewMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostTrendingMetricsViewRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_POST_TRENDING_METRICS_VIEW)))
          .addMethod(
            getListTrendingMetricsViewsMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListTrendingMetricsViewsRequest,
                com.clarifai.grpc.api.MultiTrendingMetricsViewResponse>(
                  this, METHODID_LIST_TRENDING_METRICS_VIEWS)))
          .build();
    }
  }

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

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

    /**
     *      * List concept relations between concepts in the platform.
     * MUST be above ListConcepts so that if concept_id is empty this will still match
     * /concepts/relations to list all the concept relations in the app.
     * 
     */
    public void listConceptRelations(com.clarifai.grpc.api.ListConceptRelationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListConceptRelationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Post concept relations to create relations between concepts in the platform.
     * 
     */
    public void postConceptRelations(com.clarifai.grpc.api.PostConceptRelationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostConceptRelationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Post concept relations to create relations between concepts in the platform.
     * 
     */
    public void deleteConceptRelations(com.clarifai.grpc.api.DeleteConceptRelationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteConceptRelationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the concepts with their positive and negative counts
     * 
     */
    public void getConceptCounts(com.clarifai.grpc.api.GetConceptCountsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetConceptCountsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific concept from an app.
     * 
     */
    public void getConcept(com.clarifai.grpc.api.GetConceptRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetConceptMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the concepts.
     * 
     */
    public void listConcepts(com.clarifai.grpc.api.ListConceptsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListConceptsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Search over the concepts to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public void postConceptsSearches(com.clarifai.grpc.api.PostConceptsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostConceptsSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Add a concept to an app.
     * 
     */
    public void postConcepts(com.clarifai.grpc.api.PostConceptsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostConceptsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch one or more concepts.
     * 
     */
    public void patchConcepts(com.clarifai.grpc.api.PatchConceptsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchConceptsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific concept from an app.
     * 
     */
    public void getConceptLanguage(com.clarifai.grpc.api.GetConceptLanguageRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetConceptLanguageMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List the concept in all the translated languages.
     * 
     */
    public void listConceptLanguages(com.clarifai.grpc.api.ListConceptLanguagesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListConceptLanguagesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Add a new translation for this concept.
     * 
     */
    public void postConceptLanguages(com.clarifai.grpc.api.PostConceptLanguagesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostConceptLanguagesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch the name for a given language names by passing in a list of concepts with the new names
     * for the languages.
     * 
     */
    public void patchConceptLanguages(com.clarifai.grpc.api.PatchConceptLanguagesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchConceptLanguagesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all domain graphs.
     * 
     */
    public void listKnowledgeGraphs(com.clarifai.grpc.api.ListKnowledgeGraphsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListKnowledgeGraphsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Post domain graphs.
     * 
     */
    public void postKnowledgeGraphs(com.clarifai.grpc.api.PostKnowledgeGraphsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostKnowledgeGraphsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Start concept mapping jobs.
     * 
     */
    public void postConceptMappingJobs(com.clarifai.grpc.api.PostConceptMappingJobsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostConceptMappingJobsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific annotation from an app.
     * 
     */
    public void getAnnotation(com.clarifai.grpc.api.GetAnnotationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetAnnotationMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the annotation.
     * 
     */
    public void listAnnotations(com.clarifai.grpc.api.ListAnnotationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListAnnotationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Post annotations.
     * 
     */
    public void postAnnotations(com.clarifai.grpc.api.PostAnnotationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostAnnotationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch one or more annotations.
     * 
     */
    public void patchAnnotations(com.clarifai.grpc.api.PatchAnnotationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchAnnotationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch annotations status by worker id and task id.
     * 
     */
    public void patchAnnotationsStatus(com.clarifai.grpc.api.PatchAnnotationsStatusRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchAnnotationsStatusMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete a single annotation.
     * 
     */
    public void deleteAnnotation(com.clarifai.grpc.api.DeleteAnnotationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteAnnotationMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete multiple annotations in one request.
     * 
     */
    public void deleteAnnotations(com.clarifai.grpc.api.DeleteAnnotationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteAnnotationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Execute a search over annotation
     * 
     */
    public void postAnnotationsSearches(com.clarifai.grpc.api.PostAnnotationsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostAnnotationsSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get input count per status.
     * 
     */
    public void getInputCount(com.clarifai.grpc.api.GetInputCountRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetInputCountMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Streams all the inputs starting from oldest assets.
     * 
     */
    public void streamInputs(com.clarifai.grpc.api.StreamInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getStreamInputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific input from an app.
     * 
     */
    public void getInputSamples(com.clarifai.grpc.api.GetInputSamplesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetInputSamplesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific input from an app.
     * 
     */
    public void getInput(com.clarifai.grpc.api.GetInputRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetInputMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the inputs.
     * 
     */
    public void listInputs(com.clarifai.grpc.api.ListInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListInputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Add an input (or set of inputs) to an app.
     * This call is synchronous if the PostInputsRequest contains exactly one image input. Otherwise,
     * it is asynchronous.
     * 
     */
    public void postInputs(com.clarifai.grpc.api.PostInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostInputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch one or more inputs.
     * 
     */
    public void patchInputs(com.clarifai.grpc.api.PatchInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchInputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete a single input asynchronously.
     * 
     */
    public void deleteInput(com.clarifai.grpc.api.DeleteInputRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteInputMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete multiple inputs in one request.
     * This call is asynchronous.
     * 
     */
    public void deleteInputs(com.clarifai.grpc.api.DeleteInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteInputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Execute a search over input
     * 
     */
    public void postInputsSearches(com.clarifai.grpc.api.PostInputsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostInputsSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get predicted outputs from the model.
     * 
     */
    public void postModelOutputs(com.clarifai.grpc.api.PostModelOutputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostModelOutputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific model type.
     * 
     */
    public void getModelType(com.clarifai.grpc.api.GetModelTypeRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetModelTypeMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the supported open source licenses in the platform.
     * 
     */
    public void listOpenSourceLicenses(com.clarifai.grpc.api.ListOpenSourceLicensesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListOpenSourceLicensesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the model types available in the platform.
     * This MUST be above ListModels so that the /models/types endpoint takes precedence.
     * 
     */
    public void listModelTypes(com.clarifai.grpc.api.ListModelTypesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListModelTypesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific model from an app.
     * 
     */
    public void getModel(com.clarifai.grpc.api.GetModelRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetModelMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a the output info for a given model_id or model_id/version_id
     * combo.
     * 
     */
    public void getModelOutputInfo(com.clarifai.grpc.api.GetModelRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetModelOutputInfoMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the models.
     * 
     */
    public void listModels(com.clarifai.grpc.api.ListModelsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListModelsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Search over the models to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public void postModelsSearches(com.clarifai.grpc.api.PostModelsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostModelsSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Add a models to an app.
     * 
     */
    public void postModels(com.clarifai.grpc.api.PostModelsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostModelsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch one or more models.
     * 
     */
    public void patchModels(com.clarifai.grpc.api.PatchModelsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchModelsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete a single model.
     * 
     */
    public void deleteModel(com.clarifai.grpc.api.DeleteModelRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteModelMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete multiple models in one request.
     * 
     */
    public void deleteModels(com.clarifai.grpc.api.DeleteModelsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteModelsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Update model toolkits tags
     * 
     */
    public void patchModelToolkits(com.clarifai.grpc.api.PatchModelToolkitsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchModelToolkitsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Update model use_cases tags
     * 
     */
    public void patchModelUseCases(com.clarifai.grpc.api.PatchModelUseCasesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchModelUseCasesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Update model languages tags
     * 
     */
    public void patchModelLanguages(com.clarifai.grpc.api.PatchModelLanguagesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchModelLanguagesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the inputs.
     * 
     */
    public void listModelInputs(com.clarifai.grpc.api.ListModelInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListModelInputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific model from an app.
     * 
     */
    public void getModelVersion(com.clarifai.grpc.api.GetModelVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetModelVersionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the models.
     * 
     */
    public void listModelVersions(com.clarifai.grpc.api.ListModelVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListModelVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * PostModelVersionsPublish
     * 
     */
    public void postModelVersionsPublish(com.clarifai.grpc.api.PostModelVersionsPublishRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostModelVersionsPublishMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * PostModelVersionsUnPublish
     * 
     */
    public void postModelVersionsUnPublish(com.clarifai.grpc.api.PostModelVersionsUnPublishRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostModelVersionsUnPublishMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Create a new model version to trigger training of the model.
     * 
     */
    public void postModelVersions(com.clarifai.grpc.api.PostModelVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostModelVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * PatchModelVersions
     * 
     */
    public void patchModelVersions(com.clarifai.grpc.api.PatchModelVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchModelVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete a single model.
     * 
     */
    public void deleteModelVersion(com.clarifai.grpc.api.DeleteModelVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteModelVersionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get the evaluation metrics for a model version.
     * 
     */
    public void getModelVersionMetrics(com.clarifai.grpc.api.GetModelVersionMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetModelVersionMetricsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Run the evaluation metrics for a model version.
     * 
     */
    public void postModelVersionMetrics(com.clarifai.grpc.api.PostModelVersionMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostModelVersionMetricsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Lists model references tied to a particular model id.
     * 
     */
    public void listModelReferences(com.clarifai.grpc.api.ListModelReferencesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListModelReferencesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * GetModelVersionInputExample
     * 
     */
    public void getModelVersionInputExample(com.clarifai.grpc.api.GetModelVersionInputExampleRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetModelVersionInputExampleMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * ListModelVersionInputExamples
     * 
     */
    public void listModelVersionInputExamples(com.clarifai.grpc.api.ListModelVersionInputExamplesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListModelVersionInputExamplesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific workflow from an app.
     * 
     */
    public void getWorkflow(com.clarifai.grpc.api.GetWorkflowRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetWorkflowMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the workflows.
     * 
     */
    public void listWorkflows(com.clarifai.grpc.api.ListWorkflowsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListWorkflowsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Add a workflow to an app.
     * 
     */
    public void postWorkflows(com.clarifai.grpc.api.PostWorkflowsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostWorkflowsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch one or more workflows.
     * 
     */
    public void patchWorkflows(com.clarifai.grpc.api.PatchWorkflowsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchWorkflowsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete a single workflow.
     * 
     */
    public void deleteWorkflow(com.clarifai.grpc.api.DeleteWorkflowRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteWorkflowMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete multiple workflows in one request.
     * 
     */
    public void deleteWorkflows(com.clarifai.grpc.api.DeleteWorkflowsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteWorkflowsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Predict using a workflow.
     * 
     */
    public void postWorkflowResults(com.clarifai.grpc.api.PostWorkflowResultsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostWorkflowResultsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Compare embeddings distances using a workflow
     * 
     */
    public void postWorkflowResultsSimilarity(com.clarifai.grpc.api.PostWorkflowResultsSimilarityRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostWorkflowResultsSimilarityMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List workflow versions.
     * 
     */
    public void listWorkflowVersions(com.clarifai.grpc.api.ListWorkflowVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListWorkflowVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get single workflow version.
     * 
     */
    public void getWorkflowVersion(com.clarifai.grpc.api.GetWorkflowVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetWorkflowVersionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete workflow versions.
     * 
     */
    public void deleteWorkflowVersions(com.clarifai.grpc.api.DeleteWorkflowVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteWorkflowVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch workflow versions.
     * 
     */
    public void patchWorkflowVersions(com.clarifai.grpc.api.PatchWorkflowVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchWorkflowVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific key from an app.
     * 
     */
    public void getKey(com.clarifai.grpc.api.GetKeyRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetKeyMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the keys.
     * 
     */
    public void listKeys(com.clarifai.grpc.api.ListKeysRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListKeysMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List keys by app_id
     * 
     */
    public void listAppKeys(com.clarifai.grpc.api.ListAppKeysRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListAppKeysMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Search over the keys to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public void deleteKey(com.clarifai.grpc.api.DeleteKeyRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteKeyMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Add a key to an app.
     * 
     */
    public void postKeys(com.clarifai.grpc.api.PostKeysRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostKeysMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch one or more keys.
     * 
     */
    public void patchKeys(com.clarifai.grpc.api.PatchKeysRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchKeysMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * API Keys in the public API -- request is itself Key authorized, and will tell
     * the user the scopes/access of the key/credential they're providing, as computed by
     * our authorizer:
     * 
     */
    public void myScopes(com.clarifai.grpc.api.MyScopesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getMyScopesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void myScopesUser(com.clarifai.grpc.api.MyScopesUserRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getMyScopesUserMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void myScopesRoot(com.clarifai.grpc.api.MyScopesRootRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getMyScopesRootMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all auth scopes available to me as a user.
     * 
     */
    public void listScopes(com.clarifai.grpc.api.ListScopesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListScopesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific app from an app.
     * 
     */
    public void getApp(com.clarifai.grpc.api.GetAppRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetAppMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the apps.
     * 
     */
    public void listApps(com.clarifai.grpc.api.ListAppsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListAppsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Search over the apps to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public void deleteApp(com.clarifai.grpc.api.DeleteAppRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteAppMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Add a app to an app.
     * This needs to load the default workflow to make a copy, validating all the models in it, and
     * then writing the new workflow back to this new app.
     * 
     */
    public void postApps(com.clarifai.grpc.api.PostAppsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostAppsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch one or more apps.
     * 
     */
    public void patchApps(com.clarifai.grpc.api.PatchAppsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchAppsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Search over the applications to find one or more you're looking for.
     * 
     */
    public void postAppsSearches(com.clarifai.grpc.api.PostAppsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostAppsSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Validate new password in real-time for a user
     * 
     */
    public void postValidatePassword(com.clarifai.grpc.api.PostValidatePasswordRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostValidatePasswordMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a saved search.
     * 
     */
    public void getSearch(com.clarifai.grpc.api.GetSearchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetSearchMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all saved searches.
     * 
     */
    public void listSearches(com.clarifai.grpc.api.ListSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Execute a new search and optionally save it.
     * 
     */
    public void postSearches(com.clarifai.grpc.api.PostSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Execute a previously saved search.
     * 
     */
    public void postSearchesByID(com.clarifai.grpc.api.PostSearchesByIDRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostSearchesByIDMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Evaluate the results of two search requests
     * 
     */
    public void postAnnotationSearchMetrics(com.clarifai.grpc.api.PostAnnotationSearchMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostAnnotationSearchMetricsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get the evaluation results between two search requests
     * 
     */
    public void getAnnotationSearchMetrics(com.clarifai.grpc.api.GetAnnotationSearchMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetAnnotationSearchMetricsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List the evaluation results between two search requests
     * 
     */
    public void listAnnotationSearchMetrics(com.clarifai.grpc.api.ListAnnotationSearchMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListAnnotationSearchMetricsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * DeleteAnnotationSearchMetrics
     * 
     */
    public void deleteAnnotationSearchMetrics(com.clarifai.grpc.api.DeleteAnnotationSearchMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteAnnotationSearchMetricsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete a saved search.
     * 
     */
    public void deleteSearch(com.clarifai.grpc.api.DeleteSearchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteSearchMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all status codes.
     * 
     */
    public void listStatusCodes(com.clarifai.grpc.api.ListStatusCodesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListStatusCodesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get more details for a status code.
     * 
     */
    public void getStatusCode(com.clarifai.grpc.api.GetStatusCodeRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetStatusCodeMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * owner list users who the app is shared with
     * 
     */
    public void listCollaborators(com.clarifai.grpc.api.ListCollaboratorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListCollaboratorsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * add collaborators to an app.
     * 
     */
    public void postCollaborators(com.clarifai.grpc.api.PostCollaboratorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostCollaboratorsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch existing collaborators.
     * 
     */
    public void patchCollaborators(com.clarifai.grpc.api.PatchCollaboratorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchCollaboratorsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete existing collaborators.
     * 
     */
    public void deleteCollaborators(com.clarifai.grpc.api.DeleteCollaboratorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteCollaboratorsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Collaboration includes the app user are invitied to work on
     * 
     */
    public void listCollaborations(com.clarifai.grpc.api.ListCollaborationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListCollaborationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * start to duplicate an app which copies all the inputs, annotations, models, concepts etc. to a new app.
     * this is an async process, you should use ListAppDuplications or GetAppDuplication to check the status.
     * 
     */
    public void postAppDuplications(com.clarifai.grpc.api.PostAppDuplicationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostAppDuplicationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * list all the app duplications user triggers
     * 
     */
    public void listAppDuplications(com.clarifai.grpc.api.ListAppDuplicationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListAppDuplicationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * get the app duplication status
     * 
     */
    public void getAppDuplication(com.clarifai.grpc.api.GetAppDuplicationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetAppDuplicationMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Add tasks to an app.
     * 
     */
    public void postTasks(com.clarifai.grpc.api.PostTasksRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostTasksMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Task annotation count
     * 
     */
    public void getTaskAnnotationCount(com.clarifai.grpc.api.GetTaskCountRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetTaskAnnotationCountMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Task Input count
     * 
     */
    public void getTaskInputCount(com.clarifai.grpc.api.GetTaskCountRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetTaskInputCountMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific task from an app.
     * 
     */
    public void getTask(com.clarifai.grpc.api.GetTaskRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetTaskMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List tasks from an app.
     * 
     */
    public void listTasks(com.clarifai.grpc.api.ListTasksRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListTasksMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch one or more tasks.
     * 
     */
    public void patchTasks(com.clarifai.grpc.api.PatchTasksRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchTasksMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete multiple tasks in one request.
     * 
     */
    public void deleteTasks(com.clarifai.grpc.api.DeleteTasksRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteTasksMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Add a list of Collectors to an app.
     * In the handler of this endpoint we also check for all the scopes of the  POST /inputs
     * endpoint.
     * Those current scopes are listed here as a hard requirement.
     * They are needed when adding the collectors just so we now that you have permission with
     * that key at least to do the writing to this app with POST /inputs.
     * 
     */
    public void postCollectors(com.clarifai.grpc.api.PostCollectorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostCollectorsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Get a specific collector from an app.
     * 
     */
    public void getCollector(com.clarifai.grpc.api.GetCollectorRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getGetCollectorMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List all the collectors.
     * 
     */
    public void listCollectors(com.clarifai.grpc.api.ListCollectorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListCollectorsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Patch one or more collectors.
     * 
     */
    public void patchCollectors(com.clarifai.grpc.api.PatchCollectorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPatchCollectorsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Delete multiple collectors in one request.
     * This call is asynchronous. Use DeleteCollector if you want a synchronous version.
     * 
     */
    public void deleteCollectors(com.clarifai.grpc.api.DeleteCollectorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getDeleteCollectorsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * PostStatValues
     * 
     */
    public void postStatValues(com.clarifai.grpc.api.PostStatValuesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostStatValuesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * PostStatValuesAggregate
     * 
     */
    public void postStatValuesAggregate(com.clarifai.grpc.api.PostStatValuesAggregateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostStatValuesAggregateMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * Increase the view metric for a detail view
     * 
     */
    public void postTrendingMetricsView(com.clarifai.grpc.api.PostTrendingMetricsViewRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPostTrendingMetricsViewMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     *      * List the view metrics for a detail view
     * 
     */
    public void listTrendingMetricsViews(com.clarifai.grpc.api.ListTrendingMetricsViewsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getListTrendingMetricsViewsMethod(), getCallOptions()), request, responseObserver);
    }
  }

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

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

    /**
     *      * List concept relations between concepts in the platform.
     * MUST be above ListConcepts so that if concept_id is empty this will still match
     * /concepts/relations to list all the concept relations in the app.
     * 
     */
    public com.clarifai.grpc.api.MultiConceptRelationResponse listConceptRelations(com.clarifai.grpc.api.ListConceptRelationsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListConceptRelationsMethod(), getCallOptions(), request);
    }

    /**
     *      * Post concept relations to create relations between concepts in the platform.
     * 
     */
    public com.clarifai.grpc.api.MultiConceptRelationResponse postConceptRelations(com.clarifai.grpc.api.PostConceptRelationsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostConceptRelationsMethod(), getCallOptions(), request);
    }

    /**
     *      * Post concept relations to create relations between concepts in the platform.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteConceptRelations(com.clarifai.grpc.api.DeleteConceptRelationsRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteConceptRelationsMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the concepts with their positive and negative counts
     * 
     */
    public com.clarifai.grpc.api.MultiConceptCountResponse getConceptCounts(com.clarifai.grpc.api.GetConceptCountsRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetConceptCountsMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific concept from an app.
     * 
     */
    public com.clarifai.grpc.api.SingleConceptResponse getConcept(com.clarifai.grpc.api.GetConceptRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetConceptMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the concepts.
     * 
     */
    public com.clarifai.grpc.api.MultiConceptResponse listConcepts(com.clarifai.grpc.api.ListConceptsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListConceptsMethod(), getCallOptions(), request);
    }

    /**
     *      * Search over the concepts to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public com.clarifai.grpc.api.MultiConceptResponse postConceptsSearches(com.clarifai.grpc.api.PostConceptsSearchesRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostConceptsSearchesMethod(), getCallOptions(), request);
    }

    /**
     *      * Add a concept to an app.
     * 
     */
    public com.clarifai.grpc.api.MultiConceptResponse postConcepts(com.clarifai.grpc.api.PostConceptsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostConceptsMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch one or more concepts.
     * 
     */
    public com.clarifai.grpc.api.MultiConceptResponse patchConcepts(com.clarifai.grpc.api.PatchConceptsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchConceptsMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific concept from an app.
     * 
     */
    public com.clarifai.grpc.api.SingleConceptLanguageResponse getConceptLanguage(com.clarifai.grpc.api.GetConceptLanguageRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetConceptLanguageMethod(), getCallOptions(), request);
    }

    /**
     *      * List the concept in all the translated languages.
     * 
     */
    public com.clarifai.grpc.api.MultiConceptLanguageResponse listConceptLanguages(com.clarifai.grpc.api.ListConceptLanguagesRequest request) {
      return blockingUnaryCall(
          getChannel(), getListConceptLanguagesMethod(), getCallOptions(), request);
    }

    /**
     *      * Add a new translation for this concept.
     * 
     */
    public com.clarifai.grpc.api.MultiConceptLanguageResponse postConceptLanguages(com.clarifai.grpc.api.PostConceptLanguagesRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostConceptLanguagesMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch the name for a given language names by passing in a list of concepts with the new names
     * for the languages.
     * 
     */
    public com.clarifai.grpc.api.MultiConceptLanguageResponse patchConceptLanguages(com.clarifai.grpc.api.PatchConceptLanguagesRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchConceptLanguagesMethod(), getCallOptions(), request);
    }

    /**
     *      * List all domain graphs.
     * 
     */
    public com.clarifai.grpc.api.MultiKnowledgeGraphResponse listKnowledgeGraphs(com.clarifai.grpc.api.ListKnowledgeGraphsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListKnowledgeGraphsMethod(), getCallOptions(), request);
    }

    /**
     *      * Post domain graphs.
     * 
     */
    public com.clarifai.grpc.api.MultiKnowledgeGraphResponse postKnowledgeGraphs(com.clarifai.grpc.api.PostKnowledgeGraphsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostKnowledgeGraphsMethod(), getCallOptions(), request);
    }

    /**
     *      * Start concept mapping jobs.
     * 
     */
    public com.clarifai.grpc.api.MultiConceptMappingJobResponse postConceptMappingJobs(com.clarifai.grpc.api.PostConceptMappingJobsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostConceptMappingJobsMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific annotation from an app.
     * 
     */
    public com.clarifai.grpc.api.SingleAnnotationResponse getAnnotation(com.clarifai.grpc.api.GetAnnotationRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetAnnotationMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the annotation.
     * 
     */
    public com.clarifai.grpc.api.MultiAnnotationResponse listAnnotations(com.clarifai.grpc.api.ListAnnotationsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListAnnotationsMethod(), getCallOptions(), request);
    }

    /**
     *      * Post annotations.
     * 
     */
    public com.clarifai.grpc.api.MultiAnnotationResponse postAnnotations(com.clarifai.grpc.api.PostAnnotationsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostAnnotationsMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch one or more annotations.
     * 
     */
    public com.clarifai.grpc.api.MultiAnnotationResponse patchAnnotations(com.clarifai.grpc.api.PatchAnnotationsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchAnnotationsMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch annotations status by worker id and task id.
     * 
     */
    public com.clarifai.grpc.api.PatchAnnotationsStatusResponse patchAnnotationsStatus(com.clarifai.grpc.api.PatchAnnotationsStatusRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchAnnotationsStatusMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete a single annotation.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteAnnotation(com.clarifai.grpc.api.DeleteAnnotationRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteAnnotationMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete multiple annotations in one request.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteAnnotations(com.clarifai.grpc.api.DeleteAnnotationsRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteAnnotationsMethod(), getCallOptions(), request);
    }

    /**
     *      * Execute a search over annotation
     * 
     */
    public com.clarifai.grpc.api.MultiSearchResponse postAnnotationsSearches(com.clarifai.grpc.api.PostAnnotationsSearchesRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostAnnotationsSearchesMethod(), getCallOptions(), request);
    }

    /**
     *      * Get input count per status.
     * 
     */
    public com.clarifai.grpc.api.SingleInputCountResponse getInputCount(com.clarifai.grpc.api.GetInputCountRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetInputCountMethod(), getCallOptions(), request);
    }

    /**
     *      * Streams all the inputs starting from oldest assets.
     * 
     */
    public com.clarifai.grpc.api.MultiInputResponse streamInputs(com.clarifai.grpc.api.StreamInputsRequest request) {
      return blockingUnaryCall(
          getChannel(), getStreamInputsMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific input from an app.
     * 
     */
    public com.clarifai.grpc.api.MultiInputAnnotationResponse getInputSamples(com.clarifai.grpc.api.GetInputSamplesRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetInputSamplesMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific input from an app.
     * 
     */
    public com.clarifai.grpc.api.SingleInputResponse getInput(com.clarifai.grpc.api.GetInputRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetInputMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the inputs.
     * 
     */
    public com.clarifai.grpc.api.MultiInputResponse listInputs(com.clarifai.grpc.api.ListInputsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListInputsMethod(), getCallOptions(), request);
    }

    /**
     *      * Add an input (or set of inputs) to an app.
     * This call is synchronous if the PostInputsRequest contains exactly one image input. Otherwise,
     * it is asynchronous.
     * 
     */
    public com.clarifai.grpc.api.MultiInputResponse postInputs(com.clarifai.grpc.api.PostInputsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostInputsMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch one or more inputs.
     * 
     */
    public com.clarifai.grpc.api.MultiInputResponse patchInputs(com.clarifai.grpc.api.PatchInputsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchInputsMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete a single input asynchronously.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteInput(com.clarifai.grpc.api.DeleteInputRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteInputMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete multiple inputs in one request.
     * This call is asynchronous.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteInputs(com.clarifai.grpc.api.DeleteInputsRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteInputsMethod(), getCallOptions(), request);
    }

    /**
     *      * Execute a search over input
     * 
     */
    public com.clarifai.grpc.api.MultiSearchResponse postInputsSearches(com.clarifai.grpc.api.PostInputsSearchesRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostInputsSearchesMethod(), getCallOptions(), request);
    }

    /**
     *      * Get predicted outputs from the model.
     * 
     */
    public com.clarifai.grpc.api.MultiOutputResponse postModelOutputs(com.clarifai.grpc.api.PostModelOutputsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostModelOutputsMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific model type.
     * 
     */
    public com.clarifai.grpc.api.SingleModelTypeResponse getModelType(com.clarifai.grpc.api.GetModelTypeRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetModelTypeMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the supported open source licenses in the platform.
     * 
     */
    public com.clarifai.grpc.api.ListOpenSourceLicensesResponse listOpenSourceLicenses(com.clarifai.grpc.api.ListOpenSourceLicensesRequest request) {
      return blockingUnaryCall(
          getChannel(), getListOpenSourceLicensesMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the model types available in the platform.
     * This MUST be above ListModels so that the /models/types endpoint takes precedence.
     * 
     */
    public com.clarifai.grpc.api.MultiModelTypeResponse listModelTypes(com.clarifai.grpc.api.ListModelTypesRequest request) {
      return blockingUnaryCall(
          getChannel(), getListModelTypesMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific model from an app.
     * 
     */
    public com.clarifai.grpc.api.SingleModelResponse getModel(com.clarifai.grpc.api.GetModelRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetModelMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a the output info for a given model_id or model_id/version_id
     * combo.
     * 
     */
    public com.clarifai.grpc.api.SingleModelResponse getModelOutputInfo(com.clarifai.grpc.api.GetModelRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetModelOutputInfoMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the models.
     * 
     */
    public com.clarifai.grpc.api.MultiModelResponse listModels(com.clarifai.grpc.api.ListModelsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListModelsMethod(), getCallOptions(), request);
    }

    /**
     *      * Search over the models to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public com.clarifai.grpc.api.MultiModelResponse postModelsSearches(com.clarifai.grpc.api.PostModelsSearchesRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostModelsSearchesMethod(), getCallOptions(), request);
    }

    /**
     *      * Add a models to an app.
     * 
     */
    public com.clarifai.grpc.api.SingleModelResponse postModels(com.clarifai.grpc.api.PostModelsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostModelsMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch one or more models.
     * 
     */
    public com.clarifai.grpc.api.MultiModelResponse patchModels(com.clarifai.grpc.api.PatchModelsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchModelsMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete a single model.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteModel(com.clarifai.grpc.api.DeleteModelRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteModelMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete multiple models in one request.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteModels(com.clarifai.grpc.api.DeleteModelsRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteModelsMethod(), getCallOptions(), request);
    }

    /**
     *      * Update model toolkits tags
     * 
     */
    public com.clarifai.grpc.api.MultiModelToolkitResponse patchModelToolkits(com.clarifai.grpc.api.PatchModelToolkitsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchModelToolkitsMethod(), getCallOptions(), request);
    }

    /**
     *      * Update model use_cases tags
     * 
     */
    public com.clarifai.grpc.api.MultiModelUseCaseResponse patchModelUseCases(com.clarifai.grpc.api.PatchModelUseCasesRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchModelUseCasesMethod(), getCallOptions(), request);
    }

    /**
     *      * Update model languages tags
     * 
     */
    public com.clarifai.grpc.api.MultiModelLanguageResponse patchModelLanguages(com.clarifai.grpc.api.PatchModelLanguagesRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchModelLanguagesMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the inputs.
     * 
     */
    public com.clarifai.grpc.api.MultiInputResponse listModelInputs(com.clarifai.grpc.api.ListModelInputsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListModelInputsMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific model from an app.
     * 
     */
    public com.clarifai.grpc.api.SingleModelVersionResponse getModelVersion(com.clarifai.grpc.api.GetModelVersionRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetModelVersionMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the models.
     * 
     */
    public com.clarifai.grpc.api.MultiModelVersionResponse listModelVersions(com.clarifai.grpc.api.ListModelVersionsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListModelVersionsMethod(), getCallOptions(), request);
    }

    /**
     *      * PostModelVersionsPublish
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse postModelVersionsPublish(com.clarifai.grpc.api.PostModelVersionsPublishRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostModelVersionsPublishMethod(), getCallOptions(), request);
    }

    /**
     *      * PostModelVersionsUnPublish
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse postModelVersionsUnPublish(com.clarifai.grpc.api.PostModelVersionsUnPublishRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostModelVersionsUnPublishMethod(), getCallOptions(), request);
    }

    /**
     *      * Create a new model version to trigger training of the model.
     * 
     */
    public com.clarifai.grpc.api.SingleModelResponse postModelVersions(com.clarifai.grpc.api.PostModelVersionsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostModelVersionsMethod(), getCallOptions(), request);
    }

    /**
     *      * PatchModelVersions
     * 
     */
    public com.clarifai.grpc.api.MultiModelVersionResponse patchModelVersions(com.clarifai.grpc.api.PatchModelVersionsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchModelVersionsMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete a single model.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteModelVersion(com.clarifai.grpc.api.DeleteModelVersionRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteModelVersionMethod(), getCallOptions(), request);
    }

    /**
     *      * Get the evaluation metrics for a model version.
     * 
     */
    public com.clarifai.grpc.api.SingleModelVersionResponse getModelVersionMetrics(com.clarifai.grpc.api.GetModelVersionMetricsRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetModelVersionMetricsMethod(), getCallOptions(), request);
    }

    /**
     *      * Run the evaluation metrics for a model version.
     * 
     */
    public com.clarifai.grpc.api.SingleModelVersionResponse postModelVersionMetrics(com.clarifai.grpc.api.PostModelVersionMetricsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostModelVersionMetricsMethod(), getCallOptions(), request);
    }

    /**
     *      * Lists model references tied to a particular model id.
     * 
     */
    public com.clarifai.grpc.api.MultiModelReferenceResponse listModelReferences(com.clarifai.grpc.api.ListModelReferencesRequest request) {
      return blockingUnaryCall(
          getChannel(), getListModelReferencesMethod(), getCallOptions(), request);
    }

    /**
     *      * GetModelVersionInputExample
     * 
     */
    public com.clarifai.grpc.api.SingleModelVersionInputExampleResponse getModelVersionInputExample(com.clarifai.grpc.api.GetModelVersionInputExampleRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetModelVersionInputExampleMethod(), getCallOptions(), request);
    }

    /**
     *      * ListModelVersionInputExamples
     * 
     */
    public com.clarifai.grpc.api.MultiModelVersionInputExampleResponse listModelVersionInputExamples(com.clarifai.grpc.api.ListModelVersionInputExamplesRequest request) {
      return blockingUnaryCall(
          getChannel(), getListModelVersionInputExamplesMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific workflow from an app.
     * 
     */
    public com.clarifai.grpc.api.SingleWorkflowResponse getWorkflow(com.clarifai.grpc.api.GetWorkflowRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetWorkflowMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the workflows.
     * 
     */
    public com.clarifai.grpc.api.MultiWorkflowResponse listWorkflows(com.clarifai.grpc.api.ListWorkflowsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListWorkflowsMethod(), getCallOptions(), request);
    }

    /**
     *      * Add a workflow to an app.
     * 
     */
    public com.clarifai.grpc.api.MultiWorkflowResponse postWorkflows(com.clarifai.grpc.api.PostWorkflowsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostWorkflowsMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch one or more workflows.
     * 
     */
    public com.clarifai.grpc.api.MultiWorkflowResponse patchWorkflows(com.clarifai.grpc.api.PatchWorkflowsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchWorkflowsMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete a single workflow.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteWorkflow(com.clarifai.grpc.api.DeleteWorkflowRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteWorkflowMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete multiple workflows in one request.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteWorkflows(com.clarifai.grpc.api.DeleteWorkflowsRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteWorkflowsMethod(), getCallOptions(), request);
    }

    /**
     *      * Predict using a workflow.
     * 
     */
    public com.clarifai.grpc.api.PostWorkflowResultsResponse postWorkflowResults(com.clarifai.grpc.api.PostWorkflowResultsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostWorkflowResultsMethod(), getCallOptions(), request);
    }

    /**
     *      * Compare embeddings distances using a workflow
     * 
     */
    public com.clarifai.grpc.api.PostWorkflowResultsSimilarityResponse postWorkflowResultsSimilarity(com.clarifai.grpc.api.PostWorkflowResultsSimilarityRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostWorkflowResultsSimilarityMethod(), getCallOptions(), request);
    }

    /**
     *      * List workflow versions.
     * 
     */
    public com.clarifai.grpc.api.MultiWorkflowVersionResponse listWorkflowVersions(com.clarifai.grpc.api.ListWorkflowVersionsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListWorkflowVersionsMethod(), getCallOptions(), request);
    }

    /**
     *      * Get single workflow version.
     * 
     */
    public com.clarifai.grpc.api.SingleWorkflowVersionResponse getWorkflowVersion(com.clarifai.grpc.api.GetWorkflowVersionRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetWorkflowVersionMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete workflow versions.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteWorkflowVersions(com.clarifai.grpc.api.DeleteWorkflowVersionsRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteWorkflowVersionsMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch workflow versions.
     * 
     */
    public com.clarifai.grpc.api.MultiWorkflowVersionResponse patchWorkflowVersions(com.clarifai.grpc.api.PatchWorkflowVersionsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchWorkflowVersionsMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific key from an app.
     * 
     */
    public com.clarifai.grpc.api.SingleKeyResponse getKey(com.clarifai.grpc.api.GetKeyRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetKeyMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the keys.
     * 
     */
    public com.clarifai.grpc.api.MultiKeyResponse listKeys(com.clarifai.grpc.api.ListKeysRequest request) {
      return blockingUnaryCall(
          getChannel(), getListKeysMethod(), getCallOptions(), request);
    }

    /**
     *      * List keys by app_id
     * 
     */
    public com.clarifai.grpc.api.MultiKeyResponse listAppKeys(com.clarifai.grpc.api.ListAppKeysRequest request) {
      return blockingUnaryCall(
          getChannel(), getListAppKeysMethod(), getCallOptions(), request);
    }

    /**
     *      * Search over the keys to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteKey(com.clarifai.grpc.api.DeleteKeyRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteKeyMethod(), getCallOptions(), request);
    }

    /**
     *      * Add a key to an app.
     * 
     */
    public com.clarifai.grpc.api.MultiKeyResponse postKeys(com.clarifai.grpc.api.PostKeysRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostKeysMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch one or more keys.
     * 
     */
    public com.clarifai.grpc.api.MultiKeyResponse patchKeys(com.clarifai.grpc.api.PatchKeysRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchKeysMethod(), getCallOptions(), request);
    }

    /**
     *      * API Keys in the public API -- request is itself Key authorized, and will tell
     * the user the scopes/access of the key/credential they're providing, as computed by
     * our authorizer:
     * 
     */
    public com.clarifai.grpc.api.MultiScopeResponse myScopes(com.clarifai.grpc.api.MyScopesRequest request) {
      return blockingUnaryCall(
          getChannel(), getMyScopesMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.MultiScopeUserResponse myScopesUser(com.clarifai.grpc.api.MyScopesUserRequest request) {
      return blockingUnaryCall(
          getChannel(), getMyScopesUserMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.MultiScopeRootResponse myScopesRoot(com.clarifai.grpc.api.MyScopesRootRequest request) {
      return blockingUnaryCall(
          getChannel(), getMyScopesRootMethod(), getCallOptions(), request);
    }

    /**
     *      * List all auth scopes available to me as a user.
     * 
     */
    public com.clarifai.grpc.api.MultiScopeDepsResponse listScopes(com.clarifai.grpc.api.ListScopesRequest request) {
      return blockingUnaryCall(
          getChannel(), getListScopesMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific app from an app.
     * 
     */
    public com.clarifai.grpc.api.SingleAppResponse getApp(com.clarifai.grpc.api.GetAppRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetAppMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the apps.
     * 
     */
    public com.clarifai.grpc.api.MultiAppResponse listApps(com.clarifai.grpc.api.ListAppsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListAppsMethod(), getCallOptions(), request);
    }

    /**
     *      * Search over the apps to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteApp(com.clarifai.grpc.api.DeleteAppRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteAppMethod(), getCallOptions(), request);
    }

    /**
     *      * Add a app to an app.
     * This needs to load the default workflow to make a copy, validating all the models in it, and
     * then writing the new workflow back to this new app.
     * 
     */
    public com.clarifai.grpc.api.MultiAppResponse postApps(com.clarifai.grpc.api.PostAppsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostAppsMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch one or more apps.
     * 
     */
    public com.clarifai.grpc.api.MultiAppResponse patchApps(com.clarifai.grpc.api.PatchAppsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchAppsMethod(), getCallOptions(), request);
    }

    /**
     *      * Search over the applications to find one or more you're looking for.
     * 
     */
    public com.clarifai.grpc.api.MultiAppResponse postAppsSearches(com.clarifai.grpc.api.PostAppsSearchesRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostAppsSearchesMethod(), getCallOptions(), request);
    }

    /**
     *      * Validate new password in real-time for a user
     * 
     */
    public com.clarifai.grpc.api.SinglePasswordValidationResponse postValidatePassword(com.clarifai.grpc.api.PostValidatePasswordRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostValidatePasswordMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a saved search.
     * 
     */
    public com.clarifai.grpc.api.SingleSearchResponse getSearch(com.clarifai.grpc.api.GetSearchRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetSearchMethod(), getCallOptions(), request);
    }

    /**
     *      * List all saved searches.
     * 
     */
    public com.clarifai.grpc.api.MultiSearchResponse listSearches(com.clarifai.grpc.api.ListSearchesRequest request) {
      return blockingUnaryCall(
          getChannel(), getListSearchesMethod(), getCallOptions(), request);
    }

    /**
     *      * Execute a new search and optionally save it.
     * 
     */
    public com.clarifai.grpc.api.MultiSearchResponse postSearches(com.clarifai.grpc.api.PostSearchesRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostSearchesMethod(), getCallOptions(), request);
    }

    /**
     *      * Execute a previously saved search.
     * 
     */
    public com.clarifai.grpc.api.MultiSearchResponse postSearchesByID(com.clarifai.grpc.api.PostSearchesByIDRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostSearchesByIDMethod(), getCallOptions(), request);
    }

    /**
     *      * Evaluate the results of two search requests
     * 
     */
    public com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse postAnnotationSearchMetrics(com.clarifai.grpc.api.PostAnnotationSearchMetricsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostAnnotationSearchMetricsMethod(), getCallOptions(), request);
    }

    /**
     *      * Get the evaluation results between two search requests
     * 
     */
    public com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse getAnnotationSearchMetrics(com.clarifai.grpc.api.GetAnnotationSearchMetricsRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetAnnotationSearchMetricsMethod(), getCallOptions(), request);
    }

    /**
     *      * List the evaluation results between two search requests
     * 
     */
    public com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse listAnnotationSearchMetrics(com.clarifai.grpc.api.ListAnnotationSearchMetricsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListAnnotationSearchMetricsMethod(), getCallOptions(), request);
    }

    /**
     *      * DeleteAnnotationSearchMetrics
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteAnnotationSearchMetrics(com.clarifai.grpc.api.DeleteAnnotationSearchMetricsRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteAnnotationSearchMetricsMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete a saved search.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteSearch(com.clarifai.grpc.api.DeleteSearchRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteSearchMethod(), getCallOptions(), request);
    }

    /**
     *      * List all status codes.
     * 
     */
    public com.clarifai.grpc.api.MultiStatusCodeResponse listStatusCodes(com.clarifai.grpc.api.ListStatusCodesRequest request) {
      return blockingUnaryCall(
          getChannel(), getListStatusCodesMethod(), getCallOptions(), request);
    }

    /**
     *      * Get more details for a status code.
     * 
     */
    public com.clarifai.grpc.api.SingleStatusCodeResponse getStatusCode(com.clarifai.grpc.api.GetStatusCodeRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetStatusCodeMethod(), getCallOptions(), request);
    }

    /**
     *      * owner list users who the app is shared with
     * 
     */
    public com.clarifai.grpc.api.MultiCollaboratorsResponse listCollaborators(com.clarifai.grpc.api.ListCollaboratorsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListCollaboratorsMethod(), getCallOptions(), request);
    }

    /**
     *      * add collaborators to an app.
     * 
     */
    public com.clarifai.grpc.api.MultiCollaboratorsResponse postCollaborators(com.clarifai.grpc.api.PostCollaboratorsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostCollaboratorsMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch existing collaborators.
     * 
     */
    public com.clarifai.grpc.api.MultiCollaboratorsResponse patchCollaborators(com.clarifai.grpc.api.PatchCollaboratorsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchCollaboratorsMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete existing collaborators.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteCollaborators(com.clarifai.grpc.api.DeleteCollaboratorsRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteCollaboratorsMethod(), getCallOptions(), request);
    }

    /**
     *      * Collaboration includes the app user are invitied to work on
     * 
     */
    public com.clarifai.grpc.api.MultiCollaborationsResponse listCollaborations(com.clarifai.grpc.api.ListCollaborationsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListCollaborationsMethod(), getCallOptions(), request);
    }

    /**
     *      * start to duplicate an app which copies all the inputs, annotations, models, concepts etc. to a new app.
     * this is an async process, you should use ListAppDuplications or GetAppDuplication to check the status.
     * 
     */
    public com.clarifai.grpc.api.MultiAppDuplicationsResponse postAppDuplications(com.clarifai.grpc.api.PostAppDuplicationsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostAppDuplicationsMethod(), getCallOptions(), request);
    }

    /**
     *      * list all the app duplications user triggers
     * 
     */
    public com.clarifai.grpc.api.MultiAppDuplicationsResponse listAppDuplications(com.clarifai.grpc.api.ListAppDuplicationsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListAppDuplicationsMethod(), getCallOptions(), request);
    }

    /**
     *      * get the app duplication status
     * 
     */
    public com.clarifai.grpc.api.SingleAppDuplicationResponse getAppDuplication(com.clarifai.grpc.api.GetAppDuplicationRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetAppDuplicationMethod(), getCallOptions(), request);
    }

    /**
     *      * Add tasks to an app.
     * 
     */
    public com.clarifai.grpc.api.MultiTaskResponse postTasks(com.clarifai.grpc.api.PostTasksRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostTasksMethod(), getCallOptions(), request);
    }

    /**
     *      * Task annotation count
     * 
     */
    public com.clarifai.grpc.api.SingleTaskCountResponse getTaskAnnotationCount(com.clarifai.grpc.api.GetTaskCountRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetTaskAnnotationCountMethod(), getCallOptions(), request);
    }

    /**
     *      * Task Input count
     * 
     */
    public com.clarifai.grpc.api.SingleTaskCountResponse getTaskInputCount(com.clarifai.grpc.api.GetTaskCountRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetTaskInputCountMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific task from an app.
     * 
     */
    public com.clarifai.grpc.api.SingleTaskResponse getTask(com.clarifai.grpc.api.GetTaskRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetTaskMethod(), getCallOptions(), request);
    }

    /**
     *      * List tasks from an app.
     * 
     */
    public com.clarifai.grpc.api.MultiTaskResponse listTasks(com.clarifai.grpc.api.ListTasksRequest request) {
      return blockingUnaryCall(
          getChannel(), getListTasksMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch one or more tasks.
     * 
     */
    public com.clarifai.grpc.api.MultiTaskResponse patchTasks(com.clarifai.grpc.api.PatchTasksRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchTasksMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete multiple tasks in one request.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteTasks(com.clarifai.grpc.api.DeleteTasksRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteTasksMethod(), getCallOptions(), request);
    }

    /**
     *      * Add a list of Collectors to an app.
     * In the handler of this endpoint we also check for all the scopes of the  POST /inputs
     * endpoint.
     * Those current scopes are listed here as a hard requirement.
     * They are needed when adding the collectors just so we now that you have permission with
     * that key at least to do the writing to this app with POST /inputs.
     * 
     */
    public com.clarifai.grpc.api.MultiCollectorResponse postCollectors(com.clarifai.grpc.api.PostCollectorsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostCollectorsMethod(), getCallOptions(), request);
    }

    /**
     *      * Get a specific collector from an app.
     * 
     */
    public com.clarifai.grpc.api.SingleCollectorResponse getCollector(com.clarifai.grpc.api.GetCollectorRequest request) {
      return blockingUnaryCall(
          getChannel(), getGetCollectorMethod(), getCallOptions(), request);
    }

    /**
     *      * List all the collectors.
     * 
     */
    public com.clarifai.grpc.api.MultiCollectorResponse listCollectors(com.clarifai.grpc.api.ListCollectorsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListCollectorsMethod(), getCallOptions(), request);
    }

    /**
     *      * Patch one or more collectors.
     * 
     */
    public com.clarifai.grpc.api.MultiCollectorResponse patchCollectors(com.clarifai.grpc.api.PatchCollectorsRequest request) {
      return blockingUnaryCall(
          getChannel(), getPatchCollectorsMethod(), getCallOptions(), request);
    }

    /**
     *      * Delete multiple collectors in one request.
     * This call is asynchronous. Use DeleteCollector if you want a synchronous version.
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteCollectors(com.clarifai.grpc.api.DeleteCollectorsRequest request) {
      return blockingUnaryCall(
          getChannel(), getDeleteCollectorsMethod(), getCallOptions(), request);
    }

    /**
     *      * PostStatValues
     * 
     */
    public com.clarifai.grpc.api.MultiStatValueResponse postStatValues(com.clarifai.grpc.api.PostStatValuesRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostStatValuesMethod(), getCallOptions(), request);
    }

    /**
     *      * PostStatValuesAggregate
     * 
     */
    public com.clarifai.grpc.api.MultiStatValueAggregateResponse postStatValuesAggregate(com.clarifai.grpc.api.PostStatValuesAggregateRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostStatValuesAggregateMethod(), getCallOptions(), request);
    }

    /**
     *      * Increase the view metric for a detail view
     * 
     */
    public com.clarifai.grpc.api.status.BaseResponse postTrendingMetricsView(com.clarifai.grpc.api.PostTrendingMetricsViewRequest request) {
      return blockingUnaryCall(
          getChannel(), getPostTrendingMetricsViewMethod(), getCallOptions(), request);
    }

    /**
     *      * List the view metrics for a detail view
     * 
     */
    public com.clarifai.grpc.api.MultiTrendingMetricsViewResponse listTrendingMetricsViews(com.clarifai.grpc.api.ListTrendingMetricsViewsRequest request) {
      return blockingUnaryCall(
          getChannel(), getListTrendingMetricsViewsMethod(), getCallOptions(), request);
    }
  }

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

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

    /**
     *      * List concept relations between concepts in the platform.
     * MUST be above ListConcepts so that if concept_id is empty this will still match
     * /concepts/relations to list all the concept relations in the app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listConceptRelations(
        com.clarifai.grpc.api.ListConceptRelationsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListConceptRelationsMethod(), getCallOptions()), request);
    }

    /**
     *      * Post concept relations to create relations between concepts in the platform.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postConceptRelations(
        com.clarifai.grpc.api.PostConceptRelationsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostConceptRelationsMethod(), getCallOptions()), request);
    }

    /**
     *      * Post concept relations to create relations between concepts in the platform.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteConceptRelations(
        com.clarifai.grpc.api.DeleteConceptRelationsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteConceptRelationsMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the concepts with their positive and negative counts
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getConceptCounts(
        com.clarifai.grpc.api.GetConceptCountsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetConceptCountsMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific concept from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getConcept(
        com.clarifai.grpc.api.GetConceptRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetConceptMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the concepts.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listConcepts(
        com.clarifai.grpc.api.ListConceptsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListConceptsMethod(), getCallOptions()), request);
    }

    /**
     *      * Search over the concepts to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postConceptsSearches(
        com.clarifai.grpc.api.PostConceptsSearchesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostConceptsSearchesMethod(), getCallOptions()), request);
    }

    /**
     *      * Add a concept to an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postConcepts(
        com.clarifai.grpc.api.PostConceptsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostConceptsMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch one or more concepts.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchConcepts(
        com.clarifai.grpc.api.PatchConceptsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchConceptsMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific concept from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getConceptLanguage(
        com.clarifai.grpc.api.GetConceptLanguageRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetConceptLanguageMethod(), getCallOptions()), request);
    }

    /**
     *      * List the concept in all the translated languages.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listConceptLanguages(
        com.clarifai.grpc.api.ListConceptLanguagesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListConceptLanguagesMethod(), getCallOptions()), request);
    }

    /**
     *      * Add a new translation for this concept.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postConceptLanguages(
        com.clarifai.grpc.api.PostConceptLanguagesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostConceptLanguagesMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch the name for a given language names by passing in a list of concepts with the new names
     * for the languages.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchConceptLanguages(
        com.clarifai.grpc.api.PatchConceptLanguagesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchConceptLanguagesMethod(), getCallOptions()), request);
    }

    /**
     *      * List all domain graphs.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listKnowledgeGraphs(
        com.clarifai.grpc.api.ListKnowledgeGraphsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListKnowledgeGraphsMethod(), getCallOptions()), request);
    }

    /**
     *      * Post domain graphs.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postKnowledgeGraphs(
        com.clarifai.grpc.api.PostKnowledgeGraphsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostKnowledgeGraphsMethod(), getCallOptions()), request);
    }

    /**
     *      * Start concept mapping jobs.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postConceptMappingJobs(
        com.clarifai.grpc.api.PostConceptMappingJobsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostConceptMappingJobsMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific annotation from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getAnnotation(
        com.clarifai.grpc.api.GetAnnotationRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetAnnotationMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the annotation.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listAnnotations(
        com.clarifai.grpc.api.ListAnnotationsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListAnnotationsMethod(), getCallOptions()), request);
    }

    /**
     *      * Post annotations.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postAnnotations(
        com.clarifai.grpc.api.PostAnnotationsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostAnnotationsMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch one or more annotations.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchAnnotations(
        com.clarifai.grpc.api.PatchAnnotationsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchAnnotationsMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch annotations status by worker id and task id.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchAnnotationsStatus(
        com.clarifai.grpc.api.PatchAnnotationsStatusRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchAnnotationsStatusMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete a single annotation.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteAnnotation(
        com.clarifai.grpc.api.DeleteAnnotationRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteAnnotationMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete multiple annotations in one request.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteAnnotations(
        com.clarifai.grpc.api.DeleteAnnotationsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteAnnotationsMethod(), getCallOptions()), request);
    }

    /**
     *      * Execute a search over annotation
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postAnnotationsSearches(
        com.clarifai.grpc.api.PostAnnotationsSearchesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostAnnotationsSearchesMethod(), getCallOptions()), request);
    }

    /**
     *      * Get input count per status.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getInputCount(
        com.clarifai.grpc.api.GetInputCountRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetInputCountMethod(), getCallOptions()), request);
    }

    /**
     *      * Streams all the inputs starting from oldest assets.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture streamInputs(
        com.clarifai.grpc.api.StreamInputsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getStreamInputsMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific input from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getInputSamples(
        com.clarifai.grpc.api.GetInputSamplesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetInputSamplesMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific input from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getInput(
        com.clarifai.grpc.api.GetInputRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetInputMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the inputs.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listInputs(
        com.clarifai.grpc.api.ListInputsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListInputsMethod(), getCallOptions()), request);
    }

    /**
     *      * Add an input (or set of inputs) to an app.
     * This call is synchronous if the PostInputsRequest contains exactly one image input. Otherwise,
     * it is asynchronous.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postInputs(
        com.clarifai.grpc.api.PostInputsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostInputsMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch one or more inputs.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchInputs(
        com.clarifai.grpc.api.PatchInputsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchInputsMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete a single input asynchronously.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteInput(
        com.clarifai.grpc.api.DeleteInputRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteInputMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete multiple inputs in one request.
     * This call is asynchronous.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteInputs(
        com.clarifai.grpc.api.DeleteInputsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteInputsMethod(), getCallOptions()), request);
    }

    /**
     *      * Execute a search over input
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postInputsSearches(
        com.clarifai.grpc.api.PostInputsSearchesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostInputsSearchesMethod(), getCallOptions()), request);
    }

    /**
     *      * Get predicted outputs from the model.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postModelOutputs(
        com.clarifai.grpc.api.PostModelOutputsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostModelOutputsMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific model type.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getModelType(
        com.clarifai.grpc.api.GetModelTypeRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetModelTypeMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the supported open source licenses in the platform.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listOpenSourceLicenses(
        com.clarifai.grpc.api.ListOpenSourceLicensesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListOpenSourceLicensesMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the model types available in the platform.
     * This MUST be above ListModels so that the /models/types endpoint takes precedence.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listModelTypes(
        com.clarifai.grpc.api.ListModelTypesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListModelTypesMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific model from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getModel(
        com.clarifai.grpc.api.GetModelRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetModelMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a the output info for a given model_id or model_id/version_id
     * combo.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getModelOutputInfo(
        com.clarifai.grpc.api.GetModelRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetModelOutputInfoMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the models.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listModels(
        com.clarifai.grpc.api.ListModelsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListModelsMethod(), getCallOptions()), request);
    }

    /**
     *      * Search over the models to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postModelsSearches(
        com.clarifai.grpc.api.PostModelsSearchesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostModelsSearchesMethod(), getCallOptions()), request);
    }

    /**
     *      * Add a models to an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postModels(
        com.clarifai.grpc.api.PostModelsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostModelsMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch one or more models.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchModels(
        com.clarifai.grpc.api.PatchModelsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchModelsMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete a single model.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteModel(
        com.clarifai.grpc.api.DeleteModelRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteModelMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete multiple models in one request.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteModels(
        com.clarifai.grpc.api.DeleteModelsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteModelsMethod(), getCallOptions()), request);
    }

    /**
     *      * Update model toolkits tags
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchModelToolkits(
        com.clarifai.grpc.api.PatchModelToolkitsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchModelToolkitsMethod(), getCallOptions()), request);
    }

    /**
     *      * Update model use_cases tags
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchModelUseCases(
        com.clarifai.grpc.api.PatchModelUseCasesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchModelUseCasesMethod(), getCallOptions()), request);
    }

    /**
     *      * Update model languages tags
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchModelLanguages(
        com.clarifai.grpc.api.PatchModelLanguagesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchModelLanguagesMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the inputs.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listModelInputs(
        com.clarifai.grpc.api.ListModelInputsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListModelInputsMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific model from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getModelVersion(
        com.clarifai.grpc.api.GetModelVersionRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetModelVersionMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the models.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listModelVersions(
        com.clarifai.grpc.api.ListModelVersionsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListModelVersionsMethod(), getCallOptions()), request);
    }

    /**
     *      * PostModelVersionsPublish
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postModelVersionsPublish(
        com.clarifai.grpc.api.PostModelVersionsPublishRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostModelVersionsPublishMethod(), getCallOptions()), request);
    }

    /**
     *      * PostModelVersionsUnPublish
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postModelVersionsUnPublish(
        com.clarifai.grpc.api.PostModelVersionsUnPublishRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostModelVersionsUnPublishMethod(), getCallOptions()), request);
    }

    /**
     *      * Create a new model version to trigger training of the model.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postModelVersions(
        com.clarifai.grpc.api.PostModelVersionsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostModelVersionsMethod(), getCallOptions()), request);
    }

    /**
     *      * PatchModelVersions
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchModelVersions(
        com.clarifai.grpc.api.PatchModelVersionsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchModelVersionsMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete a single model.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteModelVersion(
        com.clarifai.grpc.api.DeleteModelVersionRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteModelVersionMethod(), getCallOptions()), request);
    }

    /**
     *      * Get the evaluation metrics for a model version.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getModelVersionMetrics(
        com.clarifai.grpc.api.GetModelVersionMetricsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetModelVersionMetricsMethod(), getCallOptions()), request);
    }

    /**
     *      * Run the evaluation metrics for a model version.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postModelVersionMetrics(
        com.clarifai.grpc.api.PostModelVersionMetricsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostModelVersionMetricsMethod(), getCallOptions()), request);
    }

    /**
     *      * Lists model references tied to a particular model id.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listModelReferences(
        com.clarifai.grpc.api.ListModelReferencesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListModelReferencesMethod(), getCallOptions()), request);
    }

    /**
     *      * GetModelVersionInputExample
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getModelVersionInputExample(
        com.clarifai.grpc.api.GetModelVersionInputExampleRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetModelVersionInputExampleMethod(), getCallOptions()), request);
    }

    /**
     *      * ListModelVersionInputExamples
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listModelVersionInputExamples(
        com.clarifai.grpc.api.ListModelVersionInputExamplesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListModelVersionInputExamplesMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific workflow from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getWorkflow(
        com.clarifai.grpc.api.GetWorkflowRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetWorkflowMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the workflows.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listWorkflows(
        com.clarifai.grpc.api.ListWorkflowsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListWorkflowsMethod(), getCallOptions()), request);
    }

    /**
     *      * Add a workflow to an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postWorkflows(
        com.clarifai.grpc.api.PostWorkflowsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostWorkflowsMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch one or more workflows.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchWorkflows(
        com.clarifai.grpc.api.PatchWorkflowsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchWorkflowsMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete a single workflow.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteWorkflow(
        com.clarifai.grpc.api.DeleteWorkflowRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteWorkflowMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete multiple workflows in one request.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteWorkflows(
        com.clarifai.grpc.api.DeleteWorkflowsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteWorkflowsMethod(), getCallOptions()), request);
    }

    /**
     *      * Predict using a workflow.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postWorkflowResults(
        com.clarifai.grpc.api.PostWorkflowResultsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostWorkflowResultsMethod(), getCallOptions()), request);
    }

    /**
     *      * Compare embeddings distances using a workflow
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postWorkflowResultsSimilarity(
        com.clarifai.grpc.api.PostWorkflowResultsSimilarityRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostWorkflowResultsSimilarityMethod(), getCallOptions()), request);
    }

    /**
     *      * List workflow versions.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listWorkflowVersions(
        com.clarifai.grpc.api.ListWorkflowVersionsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListWorkflowVersionsMethod(), getCallOptions()), request);
    }

    /**
     *      * Get single workflow version.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getWorkflowVersion(
        com.clarifai.grpc.api.GetWorkflowVersionRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetWorkflowVersionMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete workflow versions.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteWorkflowVersions(
        com.clarifai.grpc.api.DeleteWorkflowVersionsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteWorkflowVersionsMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch workflow versions.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchWorkflowVersions(
        com.clarifai.grpc.api.PatchWorkflowVersionsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchWorkflowVersionsMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific key from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getKey(
        com.clarifai.grpc.api.GetKeyRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetKeyMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the keys.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listKeys(
        com.clarifai.grpc.api.ListKeysRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListKeysMethod(), getCallOptions()), request);
    }

    /**
     *      * List keys by app_id
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listAppKeys(
        com.clarifai.grpc.api.ListAppKeysRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListAppKeysMethod(), getCallOptions()), request);
    }

    /**
     *      * Search over the keys to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteKey(
        com.clarifai.grpc.api.DeleteKeyRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteKeyMethod(), getCallOptions()), request);
    }

    /**
     *      * Add a key to an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postKeys(
        com.clarifai.grpc.api.PostKeysRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostKeysMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch one or more keys.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchKeys(
        com.clarifai.grpc.api.PatchKeysRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchKeysMethod(), getCallOptions()), request);
    }

    /**
     *      * API Keys in the public API -- request is itself Key authorized, and will tell
     * the user the scopes/access of the key/credential they're providing, as computed by
     * our authorizer:
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture myScopes(
        com.clarifai.grpc.api.MyScopesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getMyScopesMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture myScopesUser(
        com.clarifai.grpc.api.MyScopesUserRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getMyScopesUserMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture myScopesRoot(
        com.clarifai.grpc.api.MyScopesRootRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getMyScopesRootMethod(), getCallOptions()), request);
    }

    /**
     *      * List all auth scopes available to me as a user.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listScopes(
        com.clarifai.grpc.api.ListScopesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListScopesMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific app from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getApp(
        com.clarifai.grpc.api.GetAppRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetAppMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the apps.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listApps(
        com.clarifai.grpc.api.ListAppsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListAppsMethod(), getCallOptions()), request);
    }

    /**
     *      * Search over the apps to find one or more you're looking for.
     * This leverage the "body" parameter because we also have page and
     * per_page as url query param variables in this request.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteApp(
        com.clarifai.grpc.api.DeleteAppRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteAppMethod(), getCallOptions()), request);
    }

    /**
     *      * Add a app to an app.
     * This needs to load the default workflow to make a copy, validating all the models in it, and
     * then writing the new workflow back to this new app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postApps(
        com.clarifai.grpc.api.PostAppsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostAppsMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch one or more apps.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchApps(
        com.clarifai.grpc.api.PatchAppsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchAppsMethod(), getCallOptions()), request);
    }

    /**
     *      * Search over the applications to find one or more you're looking for.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postAppsSearches(
        com.clarifai.grpc.api.PostAppsSearchesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostAppsSearchesMethod(), getCallOptions()), request);
    }

    /**
     *      * Validate new password in real-time for a user
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postValidatePassword(
        com.clarifai.grpc.api.PostValidatePasswordRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostValidatePasswordMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a saved search.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getSearch(
        com.clarifai.grpc.api.GetSearchRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetSearchMethod(), getCallOptions()), request);
    }

    /**
     *      * List all saved searches.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listSearches(
        com.clarifai.grpc.api.ListSearchesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListSearchesMethod(), getCallOptions()), request);
    }

    /**
     *      * Execute a new search and optionally save it.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postSearches(
        com.clarifai.grpc.api.PostSearchesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostSearchesMethod(), getCallOptions()), request);
    }

    /**
     *      * Execute a previously saved search.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postSearchesByID(
        com.clarifai.grpc.api.PostSearchesByIDRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostSearchesByIDMethod(), getCallOptions()), request);
    }

    /**
     *      * Evaluate the results of two search requests
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postAnnotationSearchMetrics(
        com.clarifai.grpc.api.PostAnnotationSearchMetricsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostAnnotationSearchMetricsMethod(), getCallOptions()), request);
    }

    /**
     *      * Get the evaluation results between two search requests
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getAnnotationSearchMetrics(
        com.clarifai.grpc.api.GetAnnotationSearchMetricsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetAnnotationSearchMetricsMethod(), getCallOptions()), request);
    }

    /**
     *      * List the evaluation results between two search requests
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listAnnotationSearchMetrics(
        com.clarifai.grpc.api.ListAnnotationSearchMetricsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListAnnotationSearchMetricsMethod(), getCallOptions()), request);
    }

    /**
     *      * DeleteAnnotationSearchMetrics
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteAnnotationSearchMetrics(
        com.clarifai.grpc.api.DeleteAnnotationSearchMetricsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteAnnotationSearchMetricsMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete a saved search.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteSearch(
        com.clarifai.grpc.api.DeleteSearchRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteSearchMethod(), getCallOptions()), request);
    }

    /**
     *      * List all status codes.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listStatusCodes(
        com.clarifai.grpc.api.ListStatusCodesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListStatusCodesMethod(), getCallOptions()), request);
    }

    /**
     *      * Get more details for a status code.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getStatusCode(
        com.clarifai.grpc.api.GetStatusCodeRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetStatusCodeMethod(), getCallOptions()), request);
    }

    /**
     *      * owner list users who the app is shared with
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listCollaborators(
        com.clarifai.grpc.api.ListCollaboratorsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListCollaboratorsMethod(), getCallOptions()), request);
    }

    /**
     *      * add collaborators to an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postCollaborators(
        com.clarifai.grpc.api.PostCollaboratorsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostCollaboratorsMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch existing collaborators.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchCollaborators(
        com.clarifai.grpc.api.PatchCollaboratorsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchCollaboratorsMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete existing collaborators.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteCollaborators(
        com.clarifai.grpc.api.DeleteCollaboratorsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteCollaboratorsMethod(), getCallOptions()), request);
    }

    /**
     *      * Collaboration includes the app user are invitied to work on
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listCollaborations(
        com.clarifai.grpc.api.ListCollaborationsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListCollaborationsMethod(), getCallOptions()), request);
    }

    /**
     *      * start to duplicate an app which copies all the inputs, annotations, models, concepts etc. to a new app.
     * this is an async process, you should use ListAppDuplications or GetAppDuplication to check the status.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postAppDuplications(
        com.clarifai.grpc.api.PostAppDuplicationsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostAppDuplicationsMethod(), getCallOptions()), request);
    }

    /**
     *      * list all the app duplications user triggers
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listAppDuplications(
        com.clarifai.grpc.api.ListAppDuplicationsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListAppDuplicationsMethod(), getCallOptions()), request);
    }

    /**
     *      * get the app duplication status
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getAppDuplication(
        com.clarifai.grpc.api.GetAppDuplicationRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetAppDuplicationMethod(), getCallOptions()), request);
    }

    /**
     *      * Add tasks to an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postTasks(
        com.clarifai.grpc.api.PostTasksRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostTasksMethod(), getCallOptions()), request);
    }

    /**
     *      * Task annotation count
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getTaskAnnotationCount(
        com.clarifai.grpc.api.GetTaskCountRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetTaskAnnotationCountMethod(), getCallOptions()), request);
    }

    /**
     *      * Task Input count
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getTaskInputCount(
        com.clarifai.grpc.api.GetTaskCountRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetTaskInputCountMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific task from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getTask(
        com.clarifai.grpc.api.GetTaskRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetTaskMethod(), getCallOptions()), request);
    }

    /**
     *      * List tasks from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listTasks(
        com.clarifai.grpc.api.ListTasksRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListTasksMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch one or more tasks.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchTasks(
        com.clarifai.grpc.api.PatchTasksRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchTasksMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete multiple tasks in one request.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteTasks(
        com.clarifai.grpc.api.DeleteTasksRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteTasksMethod(), getCallOptions()), request);
    }

    /**
     *      * Add a list of Collectors to an app.
     * In the handler of this endpoint we also check for all the scopes of the  POST /inputs
     * endpoint.
     * Those current scopes are listed here as a hard requirement.
     * They are needed when adding the collectors just so we now that you have permission with
     * that key at least to do the writing to this app with POST /inputs.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postCollectors(
        com.clarifai.grpc.api.PostCollectorsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostCollectorsMethod(), getCallOptions()), request);
    }

    /**
     *      * Get a specific collector from an app.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture getCollector(
        com.clarifai.grpc.api.GetCollectorRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getGetCollectorMethod(), getCallOptions()), request);
    }

    /**
     *      * List all the collectors.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listCollectors(
        com.clarifai.grpc.api.ListCollectorsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListCollectorsMethod(), getCallOptions()), request);
    }

    /**
     *      * Patch one or more collectors.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture patchCollectors(
        com.clarifai.grpc.api.PatchCollectorsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPatchCollectorsMethod(), getCallOptions()), request);
    }

    /**
     *      * Delete multiple collectors in one request.
     * This call is asynchronous. Use DeleteCollector if you want a synchronous version.
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture deleteCollectors(
        com.clarifai.grpc.api.DeleteCollectorsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getDeleteCollectorsMethod(), getCallOptions()), request);
    }

    /**
     *      * PostStatValues
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postStatValues(
        com.clarifai.grpc.api.PostStatValuesRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostStatValuesMethod(), getCallOptions()), request);
    }

    /**
     *      * PostStatValuesAggregate
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postStatValuesAggregate(
        com.clarifai.grpc.api.PostStatValuesAggregateRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostStatValuesAggregateMethod(), getCallOptions()), request);
    }

    /**
     *      * Increase the view metric for a detail view
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture postTrendingMetricsView(
        com.clarifai.grpc.api.PostTrendingMetricsViewRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getPostTrendingMetricsViewMethod(), getCallOptions()), request);
    }

    /**
     *      * List the view metrics for a detail view
     * 
     */
    public com.google.common.util.concurrent.ListenableFuture listTrendingMetricsViews(
        com.clarifai.grpc.api.ListTrendingMetricsViewsRequest request) {
      return futureUnaryCall(
          getChannel().newCall(getListTrendingMetricsViewsMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_LIST_CONCEPT_RELATIONS = 0;
  private static final int METHODID_POST_CONCEPT_RELATIONS = 1;
  private static final int METHODID_DELETE_CONCEPT_RELATIONS = 2;
  private static final int METHODID_GET_CONCEPT_COUNTS = 3;
  private static final int METHODID_GET_CONCEPT = 4;
  private static final int METHODID_LIST_CONCEPTS = 5;
  private static final int METHODID_POST_CONCEPTS_SEARCHES = 6;
  private static final int METHODID_POST_CONCEPTS = 7;
  private static final int METHODID_PATCH_CONCEPTS = 8;
  private static final int METHODID_GET_CONCEPT_LANGUAGE = 9;
  private static final int METHODID_LIST_CONCEPT_LANGUAGES = 10;
  private static final int METHODID_POST_CONCEPT_LANGUAGES = 11;
  private static final int METHODID_PATCH_CONCEPT_LANGUAGES = 12;
  private static final int METHODID_LIST_KNOWLEDGE_GRAPHS = 13;
  private static final int METHODID_POST_KNOWLEDGE_GRAPHS = 14;
  private static final int METHODID_POST_CONCEPT_MAPPING_JOBS = 15;
  private static final int METHODID_GET_ANNOTATION = 16;
  private static final int METHODID_LIST_ANNOTATIONS = 17;
  private static final int METHODID_POST_ANNOTATIONS = 18;
  private static final int METHODID_PATCH_ANNOTATIONS = 19;
  private static final int METHODID_PATCH_ANNOTATIONS_STATUS = 20;
  private static final int METHODID_DELETE_ANNOTATION = 21;
  private static final int METHODID_DELETE_ANNOTATIONS = 22;
  private static final int METHODID_POST_ANNOTATIONS_SEARCHES = 23;
  private static final int METHODID_GET_INPUT_COUNT = 24;
  private static final int METHODID_STREAM_INPUTS = 25;
  private static final int METHODID_GET_INPUT_SAMPLES = 26;
  private static final int METHODID_GET_INPUT = 27;
  private static final int METHODID_LIST_INPUTS = 28;
  private static final int METHODID_POST_INPUTS = 29;
  private static final int METHODID_PATCH_INPUTS = 30;
  private static final int METHODID_DELETE_INPUT = 31;
  private static final int METHODID_DELETE_INPUTS = 32;
  private static final int METHODID_POST_INPUTS_SEARCHES = 33;
  private static final int METHODID_POST_MODEL_OUTPUTS = 34;
  private static final int METHODID_GET_MODEL_TYPE = 35;
  private static final int METHODID_LIST_OPEN_SOURCE_LICENSES = 36;
  private static final int METHODID_LIST_MODEL_TYPES = 37;
  private static final int METHODID_GET_MODEL = 38;
  private static final int METHODID_GET_MODEL_OUTPUT_INFO = 39;
  private static final int METHODID_LIST_MODELS = 40;
  private static final int METHODID_POST_MODELS_SEARCHES = 41;
  private static final int METHODID_POST_MODELS = 42;
  private static final int METHODID_PATCH_MODELS = 43;
  private static final int METHODID_DELETE_MODEL = 44;
  private static final int METHODID_DELETE_MODELS = 45;
  private static final int METHODID_PATCH_MODEL_TOOLKITS = 46;
  private static final int METHODID_PATCH_MODEL_USE_CASES = 47;
  private static final int METHODID_PATCH_MODEL_LANGUAGES = 48;
  private static final int METHODID_LIST_MODEL_INPUTS = 49;
  private static final int METHODID_GET_MODEL_VERSION = 50;
  private static final int METHODID_LIST_MODEL_VERSIONS = 51;
  private static final int METHODID_POST_MODEL_VERSIONS_PUBLISH = 52;
  private static final int METHODID_POST_MODEL_VERSIONS_UN_PUBLISH = 53;
  private static final int METHODID_POST_MODEL_VERSIONS = 54;
  private static final int METHODID_PATCH_MODEL_VERSIONS = 55;
  private static final int METHODID_DELETE_MODEL_VERSION = 56;
  private static final int METHODID_GET_MODEL_VERSION_METRICS = 57;
  private static final int METHODID_POST_MODEL_VERSION_METRICS = 58;
  private static final int METHODID_LIST_MODEL_REFERENCES = 59;
  private static final int METHODID_GET_MODEL_VERSION_INPUT_EXAMPLE = 60;
  private static final int METHODID_LIST_MODEL_VERSION_INPUT_EXAMPLES = 61;
  private static final int METHODID_GET_WORKFLOW = 62;
  private static final int METHODID_LIST_WORKFLOWS = 63;
  private static final int METHODID_POST_WORKFLOWS = 64;
  private static final int METHODID_PATCH_WORKFLOWS = 65;
  private static final int METHODID_DELETE_WORKFLOW = 66;
  private static final int METHODID_DELETE_WORKFLOWS = 67;
  private static final int METHODID_POST_WORKFLOW_RESULTS = 68;
  private static final int METHODID_POST_WORKFLOW_RESULTS_SIMILARITY = 69;
  private static final int METHODID_LIST_WORKFLOW_VERSIONS = 70;
  private static final int METHODID_GET_WORKFLOW_VERSION = 71;
  private static final int METHODID_DELETE_WORKFLOW_VERSIONS = 72;
  private static final int METHODID_PATCH_WORKFLOW_VERSIONS = 73;
  private static final int METHODID_GET_KEY = 74;
  private static final int METHODID_LIST_KEYS = 75;
  private static final int METHODID_LIST_APP_KEYS = 76;
  private static final int METHODID_DELETE_KEY = 77;
  private static final int METHODID_POST_KEYS = 78;
  private static final int METHODID_PATCH_KEYS = 79;
  private static final int METHODID_MY_SCOPES = 80;
  private static final int METHODID_MY_SCOPES_USER = 81;
  private static final int METHODID_MY_SCOPES_ROOT = 82;
  private static final int METHODID_LIST_SCOPES = 83;
  private static final int METHODID_GET_APP = 84;
  private static final int METHODID_LIST_APPS = 85;
  private static final int METHODID_DELETE_APP = 86;
  private static final int METHODID_POST_APPS = 87;
  private static final int METHODID_PATCH_APPS = 88;
  private static final int METHODID_POST_APPS_SEARCHES = 89;
  private static final int METHODID_POST_VALIDATE_PASSWORD = 90;
  private static final int METHODID_GET_SEARCH = 91;
  private static final int METHODID_LIST_SEARCHES = 92;
  private static final int METHODID_POST_SEARCHES = 93;
  private static final int METHODID_POST_SEARCHES_BY_ID = 94;
  private static final int METHODID_POST_ANNOTATION_SEARCH_METRICS = 95;
  private static final int METHODID_GET_ANNOTATION_SEARCH_METRICS = 96;
  private static final int METHODID_LIST_ANNOTATION_SEARCH_METRICS = 97;
  private static final int METHODID_DELETE_ANNOTATION_SEARCH_METRICS = 98;
  private static final int METHODID_DELETE_SEARCH = 99;
  private static final int METHODID_LIST_STATUS_CODES = 100;
  private static final int METHODID_GET_STATUS_CODE = 101;
  private static final int METHODID_LIST_COLLABORATORS = 102;
  private static final int METHODID_POST_COLLABORATORS = 103;
  private static final int METHODID_PATCH_COLLABORATORS = 104;
  private static final int METHODID_DELETE_COLLABORATORS = 105;
  private static final int METHODID_LIST_COLLABORATIONS = 106;
  private static final int METHODID_POST_APP_DUPLICATIONS = 107;
  private static final int METHODID_LIST_APP_DUPLICATIONS = 108;
  private static final int METHODID_GET_APP_DUPLICATION = 109;
  private static final int METHODID_POST_TASKS = 110;
  private static final int METHODID_GET_TASK_ANNOTATION_COUNT = 111;
  private static final int METHODID_GET_TASK_INPUT_COUNT = 112;
  private static final int METHODID_GET_TASK = 113;
  private static final int METHODID_LIST_TASKS = 114;
  private static final int METHODID_PATCH_TASKS = 115;
  private static final int METHODID_DELETE_TASKS = 116;
  private static final int METHODID_POST_COLLECTORS = 117;
  private static final int METHODID_GET_COLLECTOR = 118;
  private static final int METHODID_LIST_COLLECTORS = 119;
  private static final int METHODID_PATCH_COLLECTORS = 120;
  private static final int METHODID_DELETE_COLLECTORS = 121;
  private static final int METHODID_POST_STAT_VALUES = 122;
  private static final int METHODID_POST_STAT_VALUES_AGGREGATE = 123;
  private static final int METHODID_POST_TRENDING_METRICS_VIEW = 124;
  private static final int METHODID_LIST_TRENDING_METRICS_VIEWS = 125;

  private static final class MethodHandlers implements
      io.grpc.stub.ServerCalls.UnaryMethod,
      io.grpc.stub.ServerCalls.ServerStreamingMethod,
      io.grpc.stub.ServerCalls.ClientStreamingMethod,
      io.grpc.stub.ServerCalls.BidiStreamingMethod {
    private final V2ImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(V2ImplBase 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 responseObserver) {
      switch (methodId) {
        case METHODID_LIST_CONCEPT_RELATIONS:
          serviceImpl.listConceptRelations((com.clarifai.grpc.api.ListConceptRelationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_CONCEPT_RELATIONS:
          serviceImpl.postConceptRelations((com.clarifai.grpc.api.PostConceptRelationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_CONCEPT_RELATIONS:
          serviceImpl.deleteConceptRelations((com.clarifai.grpc.api.DeleteConceptRelationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_CONCEPT_COUNTS:
          serviceImpl.getConceptCounts((com.clarifai.grpc.api.GetConceptCountsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_CONCEPT:
          serviceImpl.getConcept((com.clarifai.grpc.api.GetConceptRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_CONCEPTS:
          serviceImpl.listConcepts((com.clarifai.grpc.api.ListConceptsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_CONCEPTS_SEARCHES:
          serviceImpl.postConceptsSearches((com.clarifai.grpc.api.PostConceptsSearchesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_CONCEPTS:
          serviceImpl.postConcepts((com.clarifai.grpc.api.PostConceptsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_CONCEPTS:
          serviceImpl.patchConcepts((com.clarifai.grpc.api.PatchConceptsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_CONCEPT_LANGUAGE:
          serviceImpl.getConceptLanguage((com.clarifai.grpc.api.GetConceptLanguageRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_CONCEPT_LANGUAGES:
          serviceImpl.listConceptLanguages((com.clarifai.grpc.api.ListConceptLanguagesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_CONCEPT_LANGUAGES:
          serviceImpl.postConceptLanguages((com.clarifai.grpc.api.PostConceptLanguagesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_CONCEPT_LANGUAGES:
          serviceImpl.patchConceptLanguages((com.clarifai.grpc.api.PatchConceptLanguagesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_KNOWLEDGE_GRAPHS:
          serviceImpl.listKnowledgeGraphs((com.clarifai.grpc.api.ListKnowledgeGraphsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_KNOWLEDGE_GRAPHS:
          serviceImpl.postKnowledgeGraphs((com.clarifai.grpc.api.PostKnowledgeGraphsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_CONCEPT_MAPPING_JOBS:
          serviceImpl.postConceptMappingJobs((com.clarifai.grpc.api.PostConceptMappingJobsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_ANNOTATION:
          serviceImpl.getAnnotation((com.clarifai.grpc.api.GetAnnotationRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_ANNOTATIONS:
          serviceImpl.listAnnotations((com.clarifai.grpc.api.ListAnnotationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_ANNOTATIONS:
          serviceImpl.postAnnotations((com.clarifai.grpc.api.PostAnnotationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_ANNOTATIONS:
          serviceImpl.patchAnnotations((com.clarifai.grpc.api.PatchAnnotationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_ANNOTATIONS_STATUS:
          serviceImpl.patchAnnotationsStatus((com.clarifai.grpc.api.PatchAnnotationsStatusRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_ANNOTATION:
          serviceImpl.deleteAnnotation((com.clarifai.grpc.api.DeleteAnnotationRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_ANNOTATIONS:
          serviceImpl.deleteAnnotations((com.clarifai.grpc.api.DeleteAnnotationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_ANNOTATIONS_SEARCHES:
          serviceImpl.postAnnotationsSearches((com.clarifai.grpc.api.PostAnnotationsSearchesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_INPUT_COUNT:
          serviceImpl.getInputCount((com.clarifai.grpc.api.GetInputCountRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_STREAM_INPUTS:
          serviceImpl.streamInputs((com.clarifai.grpc.api.StreamInputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_INPUT_SAMPLES:
          serviceImpl.getInputSamples((com.clarifai.grpc.api.GetInputSamplesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_INPUT:
          serviceImpl.getInput((com.clarifai.grpc.api.GetInputRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_INPUTS:
          serviceImpl.listInputs((com.clarifai.grpc.api.ListInputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_INPUTS:
          serviceImpl.postInputs((com.clarifai.grpc.api.PostInputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_INPUTS:
          serviceImpl.patchInputs((com.clarifai.grpc.api.PatchInputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_INPUT:
          serviceImpl.deleteInput((com.clarifai.grpc.api.DeleteInputRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_INPUTS:
          serviceImpl.deleteInputs((com.clarifai.grpc.api.DeleteInputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_INPUTS_SEARCHES:
          serviceImpl.postInputsSearches((com.clarifai.grpc.api.PostInputsSearchesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_MODEL_OUTPUTS:
          serviceImpl.postModelOutputs((com.clarifai.grpc.api.PostModelOutputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MODEL_TYPE:
          serviceImpl.getModelType((com.clarifai.grpc.api.GetModelTypeRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_OPEN_SOURCE_LICENSES:
          serviceImpl.listOpenSourceLicenses((com.clarifai.grpc.api.ListOpenSourceLicensesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_MODEL_TYPES:
          serviceImpl.listModelTypes((com.clarifai.grpc.api.ListModelTypesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MODEL:
          serviceImpl.getModel((com.clarifai.grpc.api.GetModelRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MODEL_OUTPUT_INFO:
          serviceImpl.getModelOutputInfo((com.clarifai.grpc.api.GetModelRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_MODELS:
          serviceImpl.listModels((com.clarifai.grpc.api.ListModelsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_MODELS_SEARCHES:
          serviceImpl.postModelsSearches((com.clarifai.grpc.api.PostModelsSearchesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_MODELS:
          serviceImpl.postModels((com.clarifai.grpc.api.PostModelsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_MODELS:
          serviceImpl.patchModels((com.clarifai.grpc.api.PatchModelsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_MODEL:
          serviceImpl.deleteModel((com.clarifai.grpc.api.DeleteModelRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_MODELS:
          serviceImpl.deleteModels((com.clarifai.grpc.api.DeleteModelsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_MODEL_TOOLKITS:
          serviceImpl.patchModelToolkits((com.clarifai.grpc.api.PatchModelToolkitsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_MODEL_USE_CASES:
          serviceImpl.patchModelUseCases((com.clarifai.grpc.api.PatchModelUseCasesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_MODEL_LANGUAGES:
          serviceImpl.patchModelLanguages((com.clarifai.grpc.api.PatchModelLanguagesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_MODEL_INPUTS:
          serviceImpl.listModelInputs((com.clarifai.grpc.api.ListModelInputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MODEL_VERSION:
          serviceImpl.getModelVersion((com.clarifai.grpc.api.GetModelVersionRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_MODEL_VERSIONS:
          serviceImpl.listModelVersions((com.clarifai.grpc.api.ListModelVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_MODEL_VERSIONS_PUBLISH:
          serviceImpl.postModelVersionsPublish((com.clarifai.grpc.api.PostModelVersionsPublishRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_MODEL_VERSIONS_UN_PUBLISH:
          serviceImpl.postModelVersionsUnPublish((com.clarifai.grpc.api.PostModelVersionsUnPublishRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_MODEL_VERSIONS:
          serviceImpl.postModelVersions((com.clarifai.grpc.api.PostModelVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_MODEL_VERSIONS:
          serviceImpl.patchModelVersions((com.clarifai.grpc.api.PatchModelVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_MODEL_VERSION:
          serviceImpl.deleteModelVersion((com.clarifai.grpc.api.DeleteModelVersionRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MODEL_VERSION_METRICS:
          serviceImpl.getModelVersionMetrics((com.clarifai.grpc.api.GetModelVersionMetricsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_MODEL_VERSION_METRICS:
          serviceImpl.postModelVersionMetrics((com.clarifai.grpc.api.PostModelVersionMetricsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_MODEL_REFERENCES:
          serviceImpl.listModelReferences((com.clarifai.grpc.api.ListModelReferencesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MODEL_VERSION_INPUT_EXAMPLE:
          serviceImpl.getModelVersionInputExample((com.clarifai.grpc.api.GetModelVersionInputExampleRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_MODEL_VERSION_INPUT_EXAMPLES:
          serviceImpl.listModelVersionInputExamples((com.clarifai.grpc.api.ListModelVersionInputExamplesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_WORKFLOW:
          serviceImpl.getWorkflow((com.clarifai.grpc.api.GetWorkflowRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_WORKFLOWS:
          serviceImpl.listWorkflows((com.clarifai.grpc.api.ListWorkflowsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_WORKFLOWS:
          serviceImpl.postWorkflows((com.clarifai.grpc.api.PostWorkflowsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_WORKFLOWS:
          serviceImpl.patchWorkflows((com.clarifai.grpc.api.PatchWorkflowsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_WORKFLOW:
          serviceImpl.deleteWorkflow((com.clarifai.grpc.api.DeleteWorkflowRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_WORKFLOWS:
          serviceImpl.deleteWorkflows((com.clarifai.grpc.api.DeleteWorkflowsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_WORKFLOW_RESULTS:
          serviceImpl.postWorkflowResults((com.clarifai.grpc.api.PostWorkflowResultsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_WORKFLOW_RESULTS_SIMILARITY:
          serviceImpl.postWorkflowResultsSimilarity((com.clarifai.grpc.api.PostWorkflowResultsSimilarityRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_WORKFLOW_VERSIONS:
          serviceImpl.listWorkflowVersions((com.clarifai.grpc.api.ListWorkflowVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_WORKFLOW_VERSION:
          serviceImpl.getWorkflowVersion((com.clarifai.grpc.api.GetWorkflowVersionRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_WORKFLOW_VERSIONS:
          serviceImpl.deleteWorkflowVersions((com.clarifai.grpc.api.DeleteWorkflowVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_WORKFLOW_VERSIONS:
          serviceImpl.patchWorkflowVersions((com.clarifai.grpc.api.PatchWorkflowVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_KEY:
          serviceImpl.getKey((com.clarifai.grpc.api.GetKeyRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_KEYS:
          serviceImpl.listKeys((com.clarifai.grpc.api.ListKeysRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_APP_KEYS:
          serviceImpl.listAppKeys((com.clarifai.grpc.api.ListAppKeysRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_KEY:
          serviceImpl.deleteKey((com.clarifai.grpc.api.DeleteKeyRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_KEYS:
          serviceImpl.postKeys((com.clarifai.grpc.api.PostKeysRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_KEYS:
          serviceImpl.patchKeys((com.clarifai.grpc.api.PatchKeysRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_MY_SCOPES:
          serviceImpl.myScopes((com.clarifai.grpc.api.MyScopesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_MY_SCOPES_USER:
          serviceImpl.myScopesUser((com.clarifai.grpc.api.MyScopesUserRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_MY_SCOPES_ROOT:
          serviceImpl.myScopesRoot((com.clarifai.grpc.api.MyScopesRootRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_SCOPES:
          serviceImpl.listScopes((com.clarifai.grpc.api.ListScopesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_APP:
          serviceImpl.getApp((com.clarifai.grpc.api.GetAppRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_APPS:
          serviceImpl.listApps((com.clarifai.grpc.api.ListAppsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_APP:
          serviceImpl.deleteApp((com.clarifai.grpc.api.DeleteAppRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_APPS:
          serviceImpl.postApps((com.clarifai.grpc.api.PostAppsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_APPS:
          serviceImpl.patchApps((com.clarifai.grpc.api.PatchAppsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_APPS_SEARCHES:
          serviceImpl.postAppsSearches((com.clarifai.grpc.api.PostAppsSearchesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_VALIDATE_PASSWORD:
          serviceImpl.postValidatePassword((com.clarifai.grpc.api.PostValidatePasswordRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_SEARCH:
          serviceImpl.getSearch((com.clarifai.grpc.api.GetSearchRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_SEARCHES:
          serviceImpl.listSearches((com.clarifai.grpc.api.ListSearchesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_SEARCHES:
          serviceImpl.postSearches((com.clarifai.grpc.api.PostSearchesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_SEARCHES_BY_ID:
          serviceImpl.postSearchesByID((com.clarifai.grpc.api.PostSearchesByIDRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_ANNOTATION_SEARCH_METRICS:
          serviceImpl.postAnnotationSearchMetrics((com.clarifai.grpc.api.PostAnnotationSearchMetricsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_ANNOTATION_SEARCH_METRICS:
          serviceImpl.getAnnotationSearchMetrics((com.clarifai.grpc.api.GetAnnotationSearchMetricsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_ANNOTATION_SEARCH_METRICS:
          serviceImpl.listAnnotationSearchMetrics((com.clarifai.grpc.api.ListAnnotationSearchMetricsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_ANNOTATION_SEARCH_METRICS:
          serviceImpl.deleteAnnotationSearchMetrics((com.clarifai.grpc.api.DeleteAnnotationSearchMetricsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_SEARCH:
          serviceImpl.deleteSearch((com.clarifai.grpc.api.DeleteSearchRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_STATUS_CODES:
          serviceImpl.listStatusCodes((com.clarifai.grpc.api.ListStatusCodesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_STATUS_CODE:
          serviceImpl.getStatusCode((com.clarifai.grpc.api.GetStatusCodeRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_COLLABORATORS:
          serviceImpl.listCollaborators((com.clarifai.grpc.api.ListCollaboratorsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_COLLABORATORS:
          serviceImpl.postCollaborators((com.clarifai.grpc.api.PostCollaboratorsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_COLLABORATORS:
          serviceImpl.patchCollaborators((com.clarifai.grpc.api.PatchCollaboratorsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_COLLABORATORS:
          serviceImpl.deleteCollaborators((com.clarifai.grpc.api.DeleteCollaboratorsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_COLLABORATIONS:
          serviceImpl.listCollaborations((com.clarifai.grpc.api.ListCollaborationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_APP_DUPLICATIONS:
          serviceImpl.postAppDuplications((com.clarifai.grpc.api.PostAppDuplicationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_APP_DUPLICATIONS:
          serviceImpl.listAppDuplications((com.clarifai.grpc.api.ListAppDuplicationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_APP_DUPLICATION:
          serviceImpl.getAppDuplication((com.clarifai.grpc.api.GetAppDuplicationRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_TASKS:
          serviceImpl.postTasks((com.clarifai.grpc.api.PostTasksRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_TASK_ANNOTATION_COUNT:
          serviceImpl.getTaskAnnotationCount((com.clarifai.grpc.api.GetTaskCountRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_TASK_INPUT_COUNT:
          serviceImpl.getTaskInputCount((com.clarifai.grpc.api.GetTaskCountRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_TASK:
          serviceImpl.getTask((com.clarifai.grpc.api.GetTaskRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_TASKS:
          serviceImpl.listTasks((com.clarifai.grpc.api.ListTasksRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_TASKS:
          serviceImpl.patchTasks((com.clarifai.grpc.api.PatchTasksRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_TASKS:
          serviceImpl.deleteTasks((com.clarifai.grpc.api.DeleteTasksRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_COLLECTORS:
          serviceImpl.postCollectors((com.clarifai.grpc.api.PostCollectorsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_COLLECTOR:
          serviceImpl.getCollector((com.clarifai.grpc.api.GetCollectorRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_COLLECTORS:
          serviceImpl.listCollectors((com.clarifai.grpc.api.ListCollectorsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_COLLECTORS:
          serviceImpl.patchCollectors((com.clarifai.grpc.api.PatchCollectorsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_COLLECTORS:
          serviceImpl.deleteCollectors((com.clarifai.grpc.api.DeleteCollectorsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_STAT_VALUES:
          serviceImpl.postStatValues((com.clarifai.grpc.api.PostStatValuesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_STAT_VALUES_AGGREGATE:
          serviceImpl.postStatValuesAggregate((com.clarifai.grpc.api.PostStatValuesAggregateRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_TRENDING_METRICS_VIEW:
          serviceImpl.postTrendingMetricsView((com.clarifai.grpc.api.PostTrendingMetricsViewRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_TRENDING_METRICS_VIEWS:
          serviceImpl.listTrendingMetricsViews((com.clarifai.grpc.api.ListTrendingMetricsViewsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

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

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

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

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

  private static final class V2FileDescriptorSupplier
      extends V2BaseDescriptorSupplier {
    V2FileDescriptorSupplier() {}
  }

  private static final class V2MethodDescriptorSupplier
      extends V2BaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    V2MethodDescriptorSupplier(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 (V2Grpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new V2FileDescriptorSupplier())
              .addMethod(getListConceptRelationsMethod())
              .addMethod(getPostConceptRelationsMethod())
              .addMethod(getDeleteConceptRelationsMethod())
              .addMethod(getGetConceptCountsMethod())
              .addMethod(getGetConceptMethod())
              .addMethod(getListConceptsMethod())
              .addMethod(getPostConceptsSearchesMethod())
              .addMethod(getPostConceptsMethod())
              .addMethod(getPatchConceptsMethod())
              .addMethod(getGetConceptLanguageMethod())
              .addMethod(getListConceptLanguagesMethod())
              .addMethod(getPostConceptLanguagesMethod())
              .addMethod(getPatchConceptLanguagesMethod())
              .addMethod(getListKnowledgeGraphsMethod())
              .addMethod(getPostKnowledgeGraphsMethod())
              .addMethod(getPostConceptMappingJobsMethod())
              .addMethod(getGetAnnotationMethod())
              .addMethod(getListAnnotationsMethod())
              .addMethod(getPostAnnotationsMethod())
              .addMethod(getPatchAnnotationsMethod())
              .addMethod(getPatchAnnotationsStatusMethod())
              .addMethod(getDeleteAnnotationMethod())
              .addMethod(getDeleteAnnotationsMethod())
              .addMethod(getPostAnnotationsSearchesMethod())
              .addMethod(getGetInputCountMethod())
              .addMethod(getStreamInputsMethod())
              .addMethod(getGetInputSamplesMethod())
              .addMethod(getGetInputMethod())
              .addMethod(getListInputsMethod())
              .addMethod(getPostInputsMethod())
              .addMethod(getPatchInputsMethod())
              .addMethod(getDeleteInputMethod())
              .addMethod(getDeleteInputsMethod())
              .addMethod(getPostInputsSearchesMethod())
              .addMethod(getPostModelOutputsMethod())
              .addMethod(getGetModelTypeMethod())
              .addMethod(getListOpenSourceLicensesMethod())
              .addMethod(getListModelTypesMethod())
              .addMethod(getGetModelMethod())
              .addMethod(getGetModelOutputInfoMethod())
              .addMethod(getListModelsMethod())
              .addMethod(getPostModelsSearchesMethod())
              .addMethod(getPostModelsMethod())
              .addMethod(getPatchModelsMethod())
              .addMethod(getDeleteModelMethod())
              .addMethod(getDeleteModelsMethod())
              .addMethod(getPatchModelToolkitsMethod())
              .addMethod(getPatchModelUseCasesMethod())
              .addMethod(getPatchModelLanguagesMethod())
              .addMethod(getListModelInputsMethod())
              .addMethod(getGetModelVersionMethod())
              .addMethod(getListModelVersionsMethod())
              .addMethod(getPostModelVersionsPublishMethod())
              .addMethod(getPostModelVersionsUnPublishMethod())
              .addMethod(getPostModelVersionsMethod())
              .addMethod(getPatchModelVersionsMethod())
              .addMethod(getDeleteModelVersionMethod())
              .addMethod(getGetModelVersionMetricsMethod())
              .addMethod(getPostModelVersionMetricsMethod())
              .addMethod(getListModelReferencesMethod())
              .addMethod(getGetModelVersionInputExampleMethod())
              .addMethod(getListModelVersionInputExamplesMethod())
              .addMethod(getGetWorkflowMethod())
              .addMethod(getListWorkflowsMethod())
              .addMethod(getPostWorkflowsMethod())
              .addMethod(getPatchWorkflowsMethod())
              .addMethod(getDeleteWorkflowMethod())
              .addMethod(getDeleteWorkflowsMethod())
              .addMethod(getPostWorkflowResultsMethod())
              .addMethod(getPostWorkflowResultsSimilarityMethod())
              .addMethod(getListWorkflowVersionsMethod())
              .addMethod(getGetWorkflowVersionMethod())
              .addMethod(getDeleteWorkflowVersionsMethod())
              .addMethod(getPatchWorkflowVersionsMethod())
              .addMethod(getGetKeyMethod())
              .addMethod(getListKeysMethod())
              .addMethod(getListAppKeysMethod())
              .addMethod(getDeleteKeyMethod())
              .addMethod(getPostKeysMethod())
              .addMethod(getPatchKeysMethod())
              .addMethod(getMyScopesMethod())
              .addMethod(getMyScopesUserMethod())
              .addMethod(getMyScopesRootMethod())
              .addMethod(getListScopesMethod())
              .addMethod(getGetAppMethod())
              .addMethod(getListAppsMethod())
              .addMethod(getDeleteAppMethod())
              .addMethod(getPostAppsMethod())
              .addMethod(getPatchAppsMethod())
              .addMethod(getPostAppsSearchesMethod())
              .addMethod(getPostValidatePasswordMethod())
              .addMethod(getGetSearchMethod())
              .addMethod(getListSearchesMethod())
              .addMethod(getPostSearchesMethod())
              .addMethod(getPostSearchesByIDMethod())
              .addMethod(getPostAnnotationSearchMetricsMethod())
              .addMethod(getGetAnnotationSearchMetricsMethod())
              .addMethod(getListAnnotationSearchMetricsMethod())
              .addMethod(getDeleteAnnotationSearchMetricsMethod())
              .addMethod(getDeleteSearchMethod())
              .addMethod(getListStatusCodesMethod())
              .addMethod(getGetStatusCodeMethod())
              .addMethod(getListCollaboratorsMethod())
              .addMethod(getPostCollaboratorsMethod())
              .addMethod(getPatchCollaboratorsMethod())
              .addMethod(getDeleteCollaboratorsMethod())
              .addMethod(getListCollaborationsMethod())
              .addMethod(getPostAppDuplicationsMethod())
              .addMethod(getListAppDuplicationsMethod())
              .addMethod(getGetAppDuplicationMethod())
              .addMethod(getPostTasksMethod())
              .addMethod(getGetTaskAnnotationCountMethod())
              .addMethod(getGetTaskInputCountMethod())
              .addMethod(getGetTaskMethod())
              .addMethod(getListTasksMethod())
              .addMethod(getPatchTasksMethod())
              .addMethod(getDeleteTasksMethod())
              .addMethod(getPostCollectorsMethod())
              .addMethod(getGetCollectorMethod())
              .addMethod(getListCollectorsMethod())
              .addMethod(getPatchCollectorsMethod())
              .addMethod(getDeleteCollectorsMethod())
              .addMethod(getPostStatValuesMethod())
              .addMethod(getPostStatValuesAggregateMethod())
              .addMethod(getPostTrendingMetricsViewMethod())
              .addMethod(getListTrendingMetricsViewsMethod())
              .build();
        }
      }
    }
    return result;
  }
}