All Downloads are FREE. Search and download functionalities are using the official Maven repository.

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

Go to download 

package com.clarifai.grpc.api;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler",
    comments = "Source: proto/clarifai/api/service.proto")
@io.grpc.stub.annotations.GrpcGenerated
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 getListModelConceptsMethod;

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

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

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

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

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

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

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

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

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

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

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GenerateModelOutputs",
      requestType = com.clarifai.grpc.api.PostModelOutputsRequest.class,
      responseType = com.clarifai.grpc.api.MultiOutputResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
  public static io.grpc.MethodDescriptor getGenerateModelOutputsMethod() {
    io.grpc.MethodDescriptor getGenerateModelOutputsMethod;
    if ((getGenerateModelOutputsMethod = V2Grpc.getGenerateModelOutputsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getGenerateModelOutputsMethod = V2Grpc.getGenerateModelOutputsMethod) == null) {
          V2Grpc.getGenerateModelOutputsMethod = getGenerateModelOutputsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GenerateModelOutputs"))
              .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("GenerateModelOutputs"))
              .build();
        }
      }
    }
    return getGenerateModelOutputsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getStreamModelOutputsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "StreamModelOutputs",
      requestType = com.clarifai.grpc.api.PostModelOutputsRequest.class,
      responseType = com.clarifai.grpc.api.MultiOutputResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
  public static io.grpc.MethodDescriptor getStreamModelOutputsMethod() {
    io.grpc.MethodDescriptor getStreamModelOutputsMethod;
    if ((getStreamModelOutputsMethod = V2Grpc.getStreamModelOutputsMethod) == null) {
      synchronized (V2Grpc.class) {
        if ((getStreamModelOutputsMethod = V2Grpc.getStreamModelOutputsMethod) == null) {
          V2Grpc.getStreamModelOutputsMethod = getStreamModelOutputsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamModelOutputs"))
              .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("StreamModelOutputs"))
              .build();
        }
      }
    }
    return getStreamModelOutputsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getListDatasetsMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetDatasetMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostDatasetsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPatchDatasetsMethod;

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

  private static volatile io.grpc.MethodDescriptor getDeleteDatasetsMethod;

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

  private static volatile io.grpc.MethodDescriptor getListDatasetInputsMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetDatasetInputMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostDatasetInputsMethod;

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

  private static volatile io.grpc.MethodDescriptor getDeleteDatasetInputsMethod;

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

  private static volatile io.grpc.MethodDescriptor getListDatasetVersionsMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetDatasetVersionMethod;

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

  private static volatile io.grpc.MethodDescriptor getListDatasetVersionMetricsGroupsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostDatasetVersionsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPatchDatasetVersionsMethod;

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

  private static volatile io.grpc.MethodDescriptor getDeleteDatasetVersionsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPutDatasetVersionExportsMethod;

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

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

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

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

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

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

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

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

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

  private static volatile io.grpc.MethodDescriptor getPostWorkflowVersionsPublishMethod;

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

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

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

  private static volatile io.grpc.MethodDescriptor getPutModelVersionExportsMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetModelVersionExportMethod;

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

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

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

  private static volatile io.grpc.MethodDescriptor getListModelVersionEvaluationsMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetModelVersionEvaluationMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostEvaluationsMethod;

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

  private static volatile io.grpc.MethodDescriptor getListEvaluationsMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetEvaluationMethod;

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

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

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

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

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

  private static volatile io.grpc.MethodDescriptor getPatchAppMethod;

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

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

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

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

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

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

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

  private static volatile io.grpc.MethodDescriptor getGetAnnotationFilterMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostAnnotationFiltersMethod;

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

  private static volatile io.grpc.MethodDescriptor getPatchAnnotationFiltersMethod;

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

  private static volatile io.grpc.MethodDescriptor getDeleteAnnotationFiltersMethod;

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

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

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

  private static volatile io.grpc.MethodDescriptor getGetLabelOrderMethod;

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

  private static volatile io.grpc.MethodDescriptor getListLabelOrdersMethod;

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

  private static volatile io.grpc.MethodDescriptor getPatchLabelOrdersMethod;

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

  private static volatile io.grpc.MethodDescriptor getDeleteLabelOrdersMethod;

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

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

  private static volatile io.grpc.MethodDescriptor getGetModuleMethod;

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

  private static volatile io.grpc.MethodDescriptor getListModulesMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostModulesMethod;

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

  private static volatile io.grpc.MethodDescriptor getPatchModulesMethod;

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

  private static volatile io.grpc.MethodDescriptor getDeleteModulesMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetModuleVersionMethod;

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

  private static volatile io.grpc.MethodDescriptor getListModuleVersionsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostModuleVersionsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPatchModuleVersionsMethod;

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

  private static volatile io.grpc.MethodDescriptor getDeleteModuleVersionsMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetModuleVersionUsageCountMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetInstalledModuleVersionMethod;

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

  private static volatile io.grpc.MethodDescriptor getListInstalledModuleVersionsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostInstalledModuleVersionsMethod;

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

  private static volatile io.grpc.MethodDescriptor getDeleteInstalledModuleVersionsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostInstalledModuleVersionsKeyMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostBulkOperationsMethod;

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

  private static volatile io.grpc.MethodDescriptor getListBulkOperationsMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetBulkOperationMethod;

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

  private static volatile io.grpc.MethodDescriptor getCancelBulkOperationsMethod;

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

  private static volatile io.grpc.MethodDescriptor getDeleteBulkOperationsMethod;

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

  private static volatile io.grpc.MethodDescriptor getListNextTaskAssignmentsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPutTaskAssignmentsMethod;

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

  private static volatile io.grpc.MethodDescriptor getListInputsAddJobsMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetInputsAddJobMethod;

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

  private static volatile io.grpc.MethodDescriptor getCancelInputsAddJobMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostUploadsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPutUploadContentPartsMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetUploadMethod;

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

  private static volatile io.grpc.MethodDescriptor getListUploadsMethod;

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

  private static volatile io.grpc.MethodDescriptor getDeleteUploadsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostInputsDataSourcesMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetInputsExtractionJobMethod;

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

  private static volatile io.grpc.MethodDescriptor getListInputsExtractionJobsMethod;

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

  private static volatile io.grpc.MethodDescriptor getCancelInputsExtractionJobsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostInputsUploadsMethod;

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

  private static volatile io.grpc.MethodDescriptor getGetRunnerMethod;

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

  private static volatile io.grpc.MethodDescriptor getListRunnersMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostRunnersMethod;

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

  private static volatile io.grpc.MethodDescriptor getDeleteRunnersMethod;

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

  private static volatile io.grpc.MethodDescriptor getListRunnerItemsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostRunnerItemOutputsMethod;

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

  private static volatile io.grpc.MethodDescriptor getProcessRunnerItemsMethod;

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

  private static volatile io.grpc.MethodDescriptor getPostModelVersionsTrainingTimeEstimateMethod;

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

  /**
   * 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) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetConceptCountsMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific concept from an app.
     * 

     */
    public void getConcept(com.clarifai.grpc.api.GetConceptRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetConceptMethod(), responseObserver);
    }

    /**
     * 
     * List all the concepts.
     * 

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

    /**
     * 
     * List models concepts.
     * 

     */
    public void listModelConcepts(com.clarifai.grpc.api.ListModelConceptsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListModelConceptsMethod(), 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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostConceptsSearchesMethod(), responseObserver);
    }

    /**
     * 
     * Add a concept to an app.
     * 

     */
    public void postConcepts(com.clarifai.grpc.api.PostConceptsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostConceptsMethod(), responseObserver);
    }

    /**
     * 
     * Patch one or more concepts.
     * 

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

    /**
     * 
     * Get a specific concept from an app.
     * 

     */
    public void getConceptLanguage(com.clarifai.grpc.api.GetConceptLanguageRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListConceptLanguagesMethod(), responseObserver);
    }

    /**
     * 
     * Add a new translation for this concept.
     * 

     */
    public void postConceptLanguages(com.clarifai.grpc.api.PostConceptLanguagesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchConceptLanguagesMethod(), responseObserver);
    }

    /**
     * 
     * List all domain graphs.
     * 

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

    /**
     * 
     * Post domain graphs.
     * 

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

    /**
     * 
     * Start concept mapping jobs.
     * 

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

    /**
     * 
     * Get a specific annotation from an app.
     * 

     */
    public void getAnnotation(com.clarifai.grpc.api.GetAnnotationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetAnnotationMethod(), responseObserver);
    }

    /**
     * 
     * List all the annotation.
     * 

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

    /**
     * 
     * Post annotations.
     * 

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

    /**
     * 
     * Patch one or more annotations.
     * 

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

    /**
     * 
     * Patch annotations status by worker id and task id.
     * Deprecated: Use PutTaskAssignments to update task annotations.
     *   For example, you can use PutTaskAssignments with action REVIEW_APPROVE
     *   to approve task assignments and associated annotations in bulk.
     * 

     */
    public void patchAnnotationsStatus(com.clarifai.grpc.api.PatchAnnotationsStatusRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchAnnotationsStatusMethod(), responseObserver);
    }

    /**
     * 
     * Delete a single annotation.
     * 

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

    /**
     * 
     * Delete multiple annotations in one request.
     * 

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

    /**
     * 
     * Patch saved annotations searches by ids.
     * 

     */
    public void patchAnnotationsSearches(com.clarifai.grpc.api.PatchAnnotationsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchAnnotationsSearchesMethod(), responseObserver);
    }

    /**
     * 
     * Execute a search over annotations
     * 

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

    /**
     * 
     * ListAnnotationWorkers lists users, models, and workflows (collectively
     * known as "workers") that have added annotations to the application.
     * 

     */
    public void listAnnotationWorkers(com.clarifai.grpc.api.ListAnnotationWorkersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListAnnotationWorkersMethod(), responseObserver);
    }

    /**
     * 
     * Get input count per status.
     * 

     */
    public void getInputCount(com.clarifai.grpc.api.GetInputCountRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStreamInputsMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific input from an app.
     * 

     */
    public void getInputSamples(com.clarifai.grpc.api.GetInputSamplesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetInputSamplesMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific input from an app.
     * 

     */
    public void getInput(com.clarifai.grpc.api.GetInputRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetInputMethod(), responseObserver);
    }

    /**
     * 
     * Get a video input manifest.
     * 

     */
    public void getInputVideoManifest(com.clarifai.grpc.api.GetVideoManifestRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetInputVideoManifestMethod(), responseObserver);
    }

    /**
     * 
     * List all the inputs.
     * 

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

    /**
     * 
     * Add 1 or more input to an app.
     * The actual inputs processing is asynchronous.
     * 

     */
    public void postInputs(com.clarifai.grpc.api.PostInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostInputsMethod(), responseObserver);
    }

    /**
     * 
     * Patch one or more inputs.
     * 

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

    /**
     * 
     * Delete a single input asynchronously.
     * 

     */
    public void deleteInput(com.clarifai.grpc.api.DeleteInputRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteInputsMethod(), responseObserver);
    }

    /**
     * 
     * Patch saved inputs searches by ids.
     * 

     */
    public void patchInputsSearches(com.clarifai.grpc.api.PatchInputsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchInputsSearchesMethod(), responseObserver);
    }

    /**
     * 
     * Execute a search over inputs
     * 

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

    /**
     * 
     * Get predicted outputs from the model.
     * 

     */
    public void postModelOutputs(com.clarifai.grpc.api.PostModelOutputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostModelOutputsMethod(), responseObserver);
    }

    /**
     * 
     * TODO(zeiler): will need to
     * Single request but streaming resopnses.
     * 

     */
    public void generateModelOutputs(com.clarifai.grpc.api.PostModelOutputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGenerateModelOutputsMethod(), responseObserver);
    }

    /**
     * 
     * Stream of requests and stream of responses
     * 

     */
    public io.grpc.stub.StreamObserver streamModelOutputs(
        io.grpc.stub.StreamObserver responseObserver) {
      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamModelOutputsMethod(), responseObserver);
    }

    /**
     * 
     * List all the datasets.
     * 

     */
    public void listDatasets(com.clarifai.grpc.api.ListDatasetsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListDatasetsMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific dataset.
     * 

     */
    public void getDataset(com.clarifai.grpc.api.GetDatasetRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetDatasetMethod(), responseObserver);
    }

    /**
     * 
     * Add datasets to an app.
     * The process is atomic, i.e. either all or no datasets are added.
     * If there is an error for one dataset,
     * the process will stop, revert the transaction and return the error.
     * 

     */
    public void postDatasets(com.clarifai.grpc.api.PostDatasetsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostDatasetsMethod(), responseObserver);
    }

    /**
     * 
     * Patch one or more datasets.
     * The process is atomic, i.e. either all or no datasets are patched.
     * If there is an error for one dataset,
     * the process will stop, revert the transaction and return the error.
     * 

     */
    public void patchDatasets(com.clarifai.grpc.api.PatchDatasetsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchDatasetsMethod(), responseObserver);
    }

    /**
     * 
     * Delete one or more datasets in a single request.
     * 

     */
    public void deleteDatasets(com.clarifai.grpc.api.DeleteDatasetsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteDatasetsMethod(), responseObserver);
    }

    /**
     * 
     * List all the dataset inputs in a dataset.
     * 

     */
    public void listDatasetInputs(com.clarifai.grpc.api.ListDatasetInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListDatasetInputsMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific dataset input.
     * 

     */
    public void getDatasetInput(com.clarifai.grpc.api.GetDatasetInputRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetDatasetInputMethod(), responseObserver);
    }

    /**
     * 
     * Add dataset inputs to a dataset.
     * The process is not atomic, i.e. if there are errors with some dataset
     * inputs, others might still be added. The response reports
     *   - SUCCESS if all dataset inputs were added,
     *   - MIXED_STATUS if only some dataset inputs were added, and
     *   - FAILURE if no dataset inputs were added.
     * Each individual dataset input in the response has the status set to
     * indicate if it was successful or if there was an error.
     * 

     */
    public void postDatasetInputs(com.clarifai.grpc.api.PostDatasetInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostDatasetInputsMethod(), responseObserver);
    }

    /**
     * 
     * Delete one or more dataset inputs in a single request.
     * 

     */
    public void deleteDatasetInputs(com.clarifai.grpc.api.DeleteDatasetInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteDatasetInputsMethod(), responseObserver);
    }

    /**
     * 
     * List all the dataset versions.
     * 

     */
    public void listDatasetVersions(com.clarifai.grpc.api.ListDatasetVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListDatasetVersionsMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific dataset version.
     * 

     */
    public void getDatasetVersion(com.clarifai.grpc.api.GetDatasetVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetDatasetVersionMethod(), responseObserver);
    }

    /**
     */
    public void listDatasetVersionMetricsGroups(com.clarifai.grpc.api.ListDatasetVersionMetricsGroupsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListDatasetVersionMetricsGroupsMethod(), responseObserver);
    }

    /**
     * 
     * Add dataset versions to a dataset.
     * 

     */
    public void postDatasetVersions(com.clarifai.grpc.api.PostDatasetVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostDatasetVersionsMethod(), responseObserver);
    }

    /**
     * 
     * Patch one or more dataset versions.
     * 

     */
    public void patchDatasetVersions(com.clarifai.grpc.api.PatchDatasetVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchDatasetVersionsMethod(), responseObserver);
    }

    /**
     * 
     * Delete one or more dataset versions in a single request.
     * 

     */
    public void deleteDatasetVersions(com.clarifai.grpc.api.DeleteDatasetVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteDatasetVersionsMethod(), responseObserver);
    }

    /**
     * 
     * Create export of a dataset version.
     * 

     */
    public void putDatasetVersionExports(com.clarifai.grpc.api.PutDatasetVersionExportsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPutDatasetVersionExportsMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific model type.
     * 

     */
    public void getModelType(com.clarifai.grpc.api.GetModelTypeRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListModelTypesMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific model from an app.
     * 

     */
    public void getModel(com.clarifai.grpc.api.GetModelRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetModelOutputInfoMethod(), responseObserver);
    }

    /**
     * 
     * List all the models.
     * 

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

    /**
     * 
     * List the resource counts for the app.
     * 

     */
    public void getResourceCounts(com.clarifai.grpc.api.GetResourceCountsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetResourceCountsMethod(), 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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostModelsSearchesMethod(), responseObserver);
    }

    /**
     * 
     * Add a models to an app.
     * 

     */
    public void postModels(com.clarifai.grpc.api.PostModelsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostModelsMethod(), responseObserver);
    }

    /**
     * 
     * Patch one or more models.
     * 

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

    /**
     * 
     * Patch one or more models ids.
     * 

     */
    public void patchModelIds(com.clarifai.grpc.api.PatchModelIdsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchModelIdsMethod(), responseObserver);
    }

    /**
     * 
     * Delete a single model.
     * 

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

    /**
     * 
     * Delete multiple models in one request.
     * 

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

    /**
     * 
     * Update model check consents
     * 

     */
    public void patchModelCheckConsents(com.clarifai.grpc.api.PatchModelCheckConsentsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchModelCheckConsentsMethod(), responseObserver);
    }

    /**
     * 
     * Update model toolkits tags
     * 

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

    /**
     * 
     * Update model use_cases tags
     * 

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

    /**
     * 
     * Update model languages tags
     * 

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

    /**
     * 
     * Deprecated: Unmaintained and ideally replaced with usage of datasets
     *   The server may refuse to accept requests to this endpoint.
     * 

     */
    @java.lang.Deprecated
    public void listModelInputs(com.clarifai.grpc.api.ListModelInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListModelInputsMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific model from an app.
     * 

     */
    public void getModelVersion(com.clarifai.grpc.api.GetModelVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetModelVersionMethod(), responseObserver);
    }

    /**
     * 
     * List all the models.
     * 

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

    /**
     */
    public void postWorkflowVersionsUnPublish(com.clarifai.grpc.api.PostWorkflowVersionsUnPublishRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostWorkflowVersionsUnPublishMethod(), responseObserver);
    }

    /**
     */
    public void postWorkflowVersionsPublish(com.clarifai.grpc.api.PostWorkflowVersionsPublishRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostWorkflowVersionsPublishMethod(), responseObserver);
    }

    /**
     * 
     * PostModelVersionsPublish
     * 

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

    /**
     * 
     * PostModelVersionsUnPublish
     * 

     */
    public void postModelVersionsUnPublish(com.clarifai.grpc.api.PostModelVersionsUnPublishRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostModelVersionsMethod(), responseObserver);
    }

    /**
     * 
     * PatchModelVersions
     * 

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

    /**
     * 
     * Delete a single model.
     * 

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

    /**
     * 
     * This is a streaming endpoint, the request has a field, upload_data, which can either be the config for the upload or the actual data to upload.
     * The config must be sent first before the model_bytes can be uploaded.
     * Once the config has been sent, the server will respond with a confirmation containing the model_version_id.
     * This is so that if your upload is interrupted, you can resume the upload by sending the config again with the model_version_id specified for your model_version.
     * The actual upload will be done via a multipart upload, the latest successful part_id will be sent from the server in the response to the model_bytes.
     * 

     */
    public io.grpc.stub.StreamObserver postModelVersionsUpload(
        io.grpc.stub.StreamObserver responseObserver) {
      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getPostModelVersionsUploadMethod(), responseObserver);
    }

    /**
     * 
     * Export a model
     * 

     */
    public void putModelVersionExports(com.clarifai.grpc.api.PutModelVersionExportsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPutModelVersionExportsMethod(), responseObserver);
    }

    /**
     * 
     * GetModelVersionExport
     * 

     */
    public void getModelVersionExport(com.clarifai.grpc.api.GetModelVersionExportRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetModelVersionExportMethod(), responseObserver);
    }

    /**
     * 
     * Get the evaluation metrics for a model version.
     * Deprecated: Use GetEvaluation instead
     *   The server may refuse to accept requests to this endpoint.
     * 

     */
    public void getModelVersionMetrics(com.clarifai.grpc.api.GetModelVersionMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetModelVersionMetricsMethod(), responseObserver);
    }

    /**
     * 
     * Deprecated, use PostEvaluations instead
     * Run the evaluation metrics for a model version.
     * 

     */
    public void postModelVersionMetrics(com.clarifai.grpc.api.PostModelVersionMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostModelVersionMetricsMethod(), responseObserver);
    }

    /**
     * 
     * Deprecated, use PostEvaluations instead
     * 

     */
    public void postModelVersionEvaluations(com.clarifai.grpc.api.PostModelVersionEvaluationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostModelVersionEvaluationsMethod(), responseObserver);
    }

    /**
     * 
     * Deprecated, use GetEvaluation instead
     * List the evaluation metrics for a model version.
     * 

     */
    public void listModelVersionEvaluations(com.clarifai.grpc.api.ListModelVersionEvaluationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListModelVersionEvaluationsMethod(), responseObserver);
    }

    /**
     * 
     * Deprecated, use GetEvaluation instead
     * Get an evaluation metrics for a model version.
     * 

     */
    public void getModelVersionEvaluation(com.clarifai.grpc.api.GetModelVersionEvaluationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetModelVersionEvaluationMethod(), responseObserver);
    }

    /**
     */
    public void postEvaluations(com.clarifai.grpc.api.PostEvaluationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostEvaluationsMethod(), responseObserver);
    }

    /**
     */
    public void listEvaluations(com.clarifai.grpc.api.ListEvaluationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListEvaluationsMethod(), responseObserver);
    }

    /**
     */
    public void getEvaluation(com.clarifai.grpc.api.GetEvaluationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetEvaluationMethod(), responseObserver);
    }

    /**
     * 
     * Lists model references tied to a particular model id.
     * 

     */
    public void listModelReferences(com.clarifai.grpc.api.ListModelReferencesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListModelReferencesMethod(), responseObserver);
    }

    /**
     * 
     * GetModelVersionInputExample
     * 

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

    /**
     * 
     * ListModelVersionInputExamples
     * 

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

    /**
     * 
     * Get a specific workflow from an app.
     * 

     */
    public void getWorkflow(com.clarifai.grpc.api.GetWorkflowRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetWorkflowMethod(), responseObserver);
    }

    /**
     * 
     * List all the workflows.
     * 

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

    /**
     * 
     * Add a workflow to an app.
     * Note(zeiler): the order of the workflows that are returned from this endpoint
     * may be different than the order in which the user provides them. This is because
     * we reorder by a sort that optimizes for performance of the graph and its dependencies.
     * When using the workflow in any future call the order returned by this endpoint
     * will be used.
     * 

     */
    public void postWorkflows(com.clarifai.grpc.api.PostWorkflowsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostWorkflowsMethod(), responseObserver);
    }

    /**
     * 
     * Patch one or more workflows.
     * 

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

    /**
     * 
     * Patch one or more workflows ids.
     * 

     */
    public void patchWorkflowIds(com.clarifai.grpc.api.PatchWorkflowIdsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchWorkflowIdsMethod(), responseObserver);
    }

    /**
     * 
     * Delete a single workflow.
     * 

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

    /**
     * 
     * Delete multiple workflows in one request.
     * 

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

    /**
     * 
     * Predict using a workflow.
     * 

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

    /**
     * 
     * Compare embeddings distances using a workflow
     * 

     */
    public void postWorkflowResultsSimilarity(com.clarifai.grpc.api.PostWorkflowResultsSimilarityRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostWorkflowResultsSimilarityMethod(), responseObserver);
    }

    /**
     * 
     * List workflow versions.
     * 

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

    /**
     * 
     * Get single workflow version.
     * 

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

    /**
     * 
     * Delete workflow versions.
     * 

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

    /**
     * 
     * Patch workflow versions.
     * 

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

    /**
     * 
     * Get a specific key from an app.
     * 

     */
    public void getKey(com.clarifai.grpc.api.GetKeyRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetKeyMethod(), responseObserver);
    }

    /**
     * 
     * List all the keys.
     * 

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

    /**
     * 
     * List keys by app_id
     * 

     */
    public void listAppKeys(com.clarifai.grpc.api.ListAppKeysRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteKeyMethod(), responseObserver);
    }

    /**
     * 
     * Add a key to an app.
     * 

     */
    public void postKeys(com.clarifai.grpc.api.PostKeysRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostKeysMethod(), responseObserver);
    }

    /**
     * 
     * Patch one or more keys.
     * 

     */
    public void patchKeys(com.clarifai.grpc.api.PatchKeysRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getMyScopesMethod(), responseObserver);
    }

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

    /**
     */
    public void myScopesRoot(com.clarifai.grpc.api.MyScopesRootRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListScopesMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific app from an app.
     * 

     */
    public void getApp(com.clarifai.grpc.api.GetAppRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetAppMethod(), responseObserver);
    }

    /**
     * 
     * List all the apps.
     * 

     */
    public void listApps(com.clarifai.grpc.api.ListAppsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostAppsMethod(), responseObserver);
    }

    /**
     * 
     * Patch one or more apps.
     * 

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

    /**
     * 
     * Patch apps ids.
     * 

     */
    public void patchAppsIds(com.clarifai.grpc.api.PatchAppsIdsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchAppsIdsMethod(), responseObserver);
    }

    /**
     * 
     * Patch one app.
     * 

     */
    public void patchApp(com.clarifai.grpc.api.PatchAppRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchAppMethod(), 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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostAppsSearchesMethod(), responseObserver);
    }

    /**
     * 
     * Get user information
     * 

     */
    public void getUser(com.clarifai.grpc.api.GetUserRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetUserMethod(), responseObserver);
    }

    /**
     * 
     * Validate new password in real-time for a user
     * 

     */
    public void postValidatePassword(com.clarifai.grpc.api.PostValidatePasswordRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostValidatePasswordMethod(), responseObserver);
    }

    /**
     * 
     * Get a saved legacy search.
     * 

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

    /**
     * 
     * List all saved legacy searches.
     * 

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

    /**
     * 
     * Patch saved legacy searches by ids.
     * 

     */
    public void patchSearches(com.clarifai.grpc.api.PatchSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchSearchesMethod(), responseObserver);
    }

    /**
     * 
     * Execute a new search and optionally save it.
     * Deprecated: Use PostInputsSearches or PostAnnotationsSearches instead.
     *  The server may refuse to accept requests to this endpoint.
     * 

     */
    @java.lang.Deprecated
    public void postSearches(com.clarifai.grpc.api.PostSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostSearchesMethod(), responseObserver);
    }

    /**
     * 
     * Execute a previously saved legacy search.
     * 

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

    /**
     * 
     * Evaluate the results of two search requests
     * 

     */
    public void postAnnotationSearchMetrics(com.clarifai.grpc.api.PostAnnotationSearchMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListAnnotationSearchMetricsMethod(), responseObserver);
    }

    /**
     * 
     * DeleteAnnotationSearchMetrics
     * 

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

    /**
     * 
     * Delete a saved search.
     * 

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

    /**
     * 
     * List all the annotation filters.
     * 

     */
    public void listAnnotationFilters(com.clarifai.grpc.api.ListAnnotationFiltersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListAnnotationFiltersMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific annotation filter.
     * 

     */
    public void getAnnotationFilter(com.clarifai.grpc.api.GetAnnotationFilterRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetAnnotationFilterMethod(), responseObserver);
    }

    /**
     * 
     * Add annotation filters.
     * 

     */
    public void postAnnotationFilters(com.clarifai.grpc.api.PostAnnotationFiltersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostAnnotationFiltersMethod(), responseObserver);
    }

    /**
     * 
     * Patch one or more annotation filters.
     * 

     */
    public void patchAnnotationFilters(com.clarifai.grpc.api.PatchAnnotationFiltersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchAnnotationFiltersMethod(), responseObserver);
    }

    /**
     * 
     * Delete one or more annotation filters in a single request.
     * 

     */
    public void deleteAnnotationFilters(com.clarifai.grpc.api.DeleteAnnotationFiltersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteAnnotationFiltersMethod(), responseObserver);
    }

    /**
     * 
     * List all status codes.
     * 

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

    /**
     * 
     * Get more details for a status code.
     * 

     */
    public void getStatusCode(com.clarifai.grpc.api.GetStatusCodeRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListCollaboratorsMethod(), responseObserver);
    }

    /**
     * 
     * add collaborators to an app.
     * 

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

    /**
     * 
     * Patch existing collaborators.
     * 

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

    /**
     * 
     * Delete existing collaborators.
     * 

     */
    public void deleteCollaborators(com.clarifai.grpc.api.DeleteCollaboratorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListCollaborationsMethod(), responseObserver);
    }

    /**
     * 
     * PostAppDuplications starts async app duplication jobs which copy resources
     * (inputs, annotations, models etc) from one application to another. It can
     * also create the destination application if it does not exist, with fields
     * (description, metadata etc) copied from the source application.
     * A duplication job can be started by any user that can read from the source
     * application (the target of this call) and can create and write to the
     * destination application. The duplication is associated with the user that
     * created it, so in order to read the status and progress of the job, that
     * user's ID has to be used in the call to GetAppDuplication, which might be
     * different to the source application owner ID in this call.
     * 

     */
    public void postAppDuplications(com.clarifai.grpc.api.PostAppDuplicationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostAppDuplicationsMethod(), responseObserver);
    }

    /**
     * 
     * ListAppDuplications lists all app duplication jobs created by the user.
     * 

     */
    public void listAppDuplications(com.clarifai.grpc.api.ListAppDuplicationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListAppDuplicationsMethod(), responseObserver);
    }

    /**
     * 
     * GetAppDuplication returns an app duplication job created by the user.
     * 

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

    /**
     * 
     * Add tasks to an app.
     * 

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

    /**
     * 
     * Task annotation count
     * 

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

    /**
     * 
     * Task Input count
     * 

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

    /**
     * 
     * Get a specific task from an app.
     * 

     */
    public void getTask(com.clarifai.grpc.api.GetTaskRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetTaskMethod(), responseObserver);
    }

    /**
     * 
     * List tasks from an app.
     * 

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

    /**
     * 
     * Patch one or more tasks.
     * 

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

    /**
     * 
     * Delete multiple tasks in one request.
     * 

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

    /**
     * 
     * Add Label orders.
     * 

     */
    public void postLabelOrders(com.clarifai.grpc.api.PostLabelOrdersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostLabelOrdersMethod(), responseObserver);
    }

    /**
     * 
     * Get a label order.
     * 

     */
    public void getLabelOrder(com.clarifai.grpc.api.GetLabelOrderRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetLabelOrderMethod(), responseObserver);
    }

    /**
     * 
     * List label orders.
     * 

     */
    public void listLabelOrders(com.clarifai.grpc.api.ListLabelOrdersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListLabelOrdersMethod(), responseObserver);
    }

    /**
     * 
     * Patch one or more label orders.
     * 

     */
    public void patchLabelOrders(com.clarifai.grpc.api.PatchLabelOrdersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchLabelOrdersMethod(), responseObserver);
    }

    /**
     * 
     * Delete multiple label orders in one request.
     * this do not change task status
     * 

     */
    public void deleteLabelOrders(com.clarifai.grpc.api.DeleteLabelOrdersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteLabelOrdersMethod(), 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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostCollectorsMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific collector from an app.
     * 

     */
    public void getCollector(com.clarifai.grpc.api.GetCollectorRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetCollectorMethod(), responseObserver);
    }

    /**
     * 
     * List all the collectors.
     * 

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

    /**
     * 
     * Patch one or more collectors.
     * 

     */
    public void patchCollectors(com.clarifai.grpc.api.PatchCollectorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteCollectorsMethod(), responseObserver);
    }

    /**
     * 
     * PostStatValues
     * 

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

    /**
     * 
     * PostStatValuesAggregate
     * 

     */
    public void postStatValuesAggregate(com.clarifai.grpc.api.PostStatValuesAggregateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.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) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListTrendingMetricsViewsMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific module from an app.
     * 

     */
    public void getModule(com.clarifai.grpc.api.GetModuleRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetModuleMethod(), responseObserver);
    }

    /**
     * 
     * List all the modules in community, by user or by app.
     * 

     */
    public void listModules(com.clarifai.grpc.api.ListModulesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListModulesMethod(), responseObserver);
    }

    /**
     * 
     * Add a modules to an app.
     * 

     */
    public void postModules(com.clarifai.grpc.api.PostModulesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostModulesMethod(), responseObserver);
    }

    /**
     * 
     * Patch one or more modules.
     * 

     */
    public void patchModules(com.clarifai.grpc.api.PatchModulesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchModulesMethod(), responseObserver);
    }

    /**
     * 
     * Delete multiple modules in one request.
     * 

     */
    public void deleteModules(com.clarifai.grpc.api.DeleteModulesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteModulesMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific module version for a module.
     * 

     */
    public void getModuleVersion(com.clarifai.grpc.api.GetModuleVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetModuleVersionMethod(), responseObserver);
    }

    /**
     * 
     * List all the modules versions for a given module.
     * 

     */
    public void listModuleVersions(com.clarifai.grpc.api.ListModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListModuleVersionsMethod(), responseObserver);
    }

    /**
     * 
     * Create a new module version to trigger training of the module.
     * 

     */
    public void postModuleVersions(com.clarifai.grpc.api.PostModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostModuleVersionsMethod(), responseObserver);
    }

    /**
     * 
     * Modify details of an existing module version.
     * 

     */
    public void patchModuleVersions(com.clarifai.grpc.api.PatchModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPatchModuleVersionsMethod(), responseObserver);
    }

    /**
     * 
     * Delete a multiple module version.
     * 

     */
    public void deleteModuleVersions(com.clarifai.grpc.api.DeleteModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteModuleVersionsMethod(), responseObserver);
    }

    /**
     * 
     * Get usage count for specific module version.
     * 

     */
    public void getModuleVersionUsageCount(com.clarifai.grpc.api.GetModuleVersionUsageCountRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetModuleVersionUsageCountMethod(), responseObserver);
    }

    /**
     * 
     * Get installed modules vesrions for an app.
     * 

     */
    public void getInstalledModuleVersion(com.clarifai.grpc.api.GetInstalledModuleVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetInstalledModuleVersionMethod(), responseObserver);
    }

    /**
     * 
     * List installed modules vesrions for an app.
     * 

     */
    public void listInstalledModuleVersions(com.clarifai.grpc.api.ListInstalledModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListInstalledModuleVersionsMethod(), responseObserver);
    }

    /**
     * 
     * Install a new module version which will deploy the specific ModuleVersion to the app in the url.
     * 

     */
    public void postInstalledModuleVersions(com.clarifai.grpc.api.PostInstalledModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostInstalledModuleVersionsMethod(), responseObserver);
    }

    /**
     * 
     * Uninstall an installed module version which will deploy the specific ModuleVersion to the app
     * in the url.
     * This cleaned up any associated caller keys so needs the Keys_Delete scope.
     * 

     */
    public void deleteInstalledModuleVersions(com.clarifai.grpc.api.DeleteInstalledModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteInstalledModuleVersionsMethod(), responseObserver);
    }

    /**
     * 
     * Assign a key that the caller owns to be used when accessing this installed module version
     * If this endpoint is called with a different key then it overwrites what is there.
     * 

     */
    public void postInstalledModuleVersionsKey(com.clarifai.grpc.api.PostInstalledModuleVersionsKeyRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostInstalledModuleVersionsKeyMethod(), responseObserver);
    }

    /**
     * 
     * Perform bulk operations on a list of inputs based on input source.
     * Operation include add, update, delete of concepts, metadata and geo data.
     * This is an Asynchronous process. Use ListBulkOperations or GetBulkOperation to check the status.
     * 

     */
    public void postBulkOperations(com.clarifai.grpc.api.PostBulkOperationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostBulkOperationsMethod(), responseObserver);
    }

    /**
     * 
     * List all the bulk operations
     * 

     */
    public void listBulkOperations(com.clarifai.grpc.api.ListBulkOperationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListBulkOperationsMethod(), responseObserver);
    }

    /**
     * 
     * Get the bulk operation details by ID
     * 

     */
    public void getBulkOperation(com.clarifai.grpc.api.GetBulkOperationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetBulkOperationMethod(), responseObserver);
    }

    /**
     * 
     * Cancel one or more bulk operations
     * 

     */
    public void cancelBulkOperations(com.clarifai.grpc.api.CancelBulkOperationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCancelBulkOperationsMethod(), responseObserver);
    }

    /**
     * 
     * delete one or more terminated bulk operations
     * 

     */
    public void deleteBulkOperations(com.clarifai.grpc.api.DeleteBulkOperationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteBulkOperationsMethod(), responseObserver);
    }

    /**
     * 
     * Deprecated: Use PutTaskAssignments with action=LABEL_START.
     *   This endpoint has initially been designed as a GET request,
     *   but has been re-designed to serve a PUT logic.
     *   In order to clearly highlight that this endpoint serves a PUT request,
     *   this endpoint has been deprecated and replaced by PutTaskAssignments with action=LABEL_START.
     * 

     */
    public void listNextTaskAssignments(com.clarifai.grpc.api.ListNextTaskAssignmentsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListNextTaskAssignmentsMethod(), responseObserver);
    }

    /**
     * 
     * PutTaskAssignments performs an action for the task assignments in given task.
     * All the actions are theoretically idempotent, but practically, in the current implementation,
     * the REVIEW_START action is not idempotent. See PutTaskAssignmentsRequestAction for more details.
     * 

     */
    public void putTaskAssignments(com.clarifai.grpc.api.PutTaskAssignmentsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPutTaskAssignmentsMethod(), responseObserver);
    }

    /**
     * 
     * List all the inputs add jobs
     * 

     */
    public void listInputsAddJobs(com.clarifai.grpc.api.ListInputsAddJobsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListInputsAddJobsMethod(), responseObserver);
    }

    /**
     * 
     * Get the input add job details by ID
     * 

     */
    public void getInputsAddJob(com.clarifai.grpc.api.GetInputsAddJobRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetInputsAddJobMethod(), responseObserver);
    }

    /**
     * 
     * cancel the input add job by ID
     * 

     */
    public void cancelInputsAddJob(com.clarifai.grpc.api.CancelInputsAddJobRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCancelInputsAddJobMethod(), responseObserver);
    }

    /**
     */
    public void postUploads(com.clarifai.grpc.api.PostUploadsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostUploadsMethod(), responseObserver);
    }

    /**
     * 
     * Upload a part of a multipart upload.
     * Behaviour on completion depends on the endpoint that was used to initiate the upload.
     * 

     */
    public void putUploadContentParts(com.clarifai.grpc.api.PutUploadContentPartsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPutUploadContentPartsMethod(), responseObserver);
    }

    /**
     */
    public void getUpload(com.clarifai.grpc.api.GetUploadRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetUploadMethod(), responseObserver);
    }

    /**
     */
    public void listUploads(com.clarifai.grpc.api.ListUploadsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListUploadsMethod(), responseObserver);
    }

    /**
     */
    public void deleteUploads(com.clarifai.grpc.api.DeleteUploadsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteUploadsMethod(), responseObserver);
    }

    /**
     * 
     * Initiates retrieval of inputs from cloud storage from a user provided data source.
     * Will create and return an inputs-add-job for tracking progress.
     * Archives will be extracted and their contents will be processed as inputs.
     * The cloud URL will be treated as a filter prefix. For example s3:/bucket/images_folder/abc will process
     * files in the images_folder beginning with abc or in a subfolder beginning with abc.
     * For example:
     * bucket/images_folder/abcImage.png
     * bucket/images_folder/abc-1/Data.zip
     * If given URL is for a private bucket or file, then credentials should be provided to access the bucket.
     * Credentials should include rights to list the objects in the bucket, except when pointed directly at a file archive,
     * in which case it only requires rights to access that particular file.
     * 

     */
    public void postInputsDataSources(com.clarifai.grpc.api.PostInputsDataSourcesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostInputsDataSourcesMethod(), responseObserver);
    }

    /**
     * 
     * Get the input extraction job details by ID
     * 

     */
    public void getInputsExtractionJob(com.clarifai.grpc.api.GetInputsExtractionJobRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetInputsExtractionJobMethod(), responseObserver);
    }

    /**
     * 
     * List all the input extraction jobs
     * 

     */
    public void listInputsExtractionJobs(com.clarifai.grpc.api.ListInputsExtractionJobsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListInputsExtractionJobsMethod(), responseObserver);
    }

    /**
     */
    public void cancelInputsExtractionJobs(com.clarifai.grpc.api.CancelInputsExtractionJobsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCancelInputsExtractionJobsMethod(), responseObserver);
    }

    /**
     * 
     * Start uploading a file archive containing inputs.
     * Will create and return an inputs-add-job for tracking progress.
     * Associated inputs-add-job contains an upload id which should be completed through `PutUploadContentParts` endpoint.
     * Completing the upload will automatically begin unpacking the archive and uploading the contents as inputs.
     * 

     */
    public void postInputsUploads(com.clarifai.grpc.api.PostInputsUploadsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostInputsUploadsMethod(), responseObserver);
    }

    /**
     * 
     * Get a specific runner.
     * TODO(zeiler): runner_id is a UUID so can list globally as well.
     * 

     */
    public void getRunner(com.clarifai.grpc.api.GetRunnerRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetRunnerMethod(), responseObserver);
    }

    /**
     * 
     * List all the runners for the user.
     * 

     */
    public void listRunners(com.clarifai.grpc.api.ListRunnersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListRunnersMethod(), responseObserver);
    }

    /**
     * 
     * Add a runners to a user.
     * 

     */
    public void postRunners(com.clarifai.grpc.api.PostRunnersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostRunnersMethod(), responseObserver);
    }

    /**
     * 
     * Delete multiple runners in one request.
     * 

     */
    public void deleteRunners(com.clarifai.grpc.api.DeleteRunnersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteRunnersMethod(), responseObserver);
    }

    /**
     * 
     * List items for the remote runner to work on.
     * since the runner_id is a UUID we can access it directly too.
     * 

     */
    public void listRunnerItems(com.clarifai.grpc.api.ListRunnerItemsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListRunnerItemsMethod(), responseObserver);
    }

    /**
     * 
     * Post back outputs from remote runners
     * since the runner_id is a UUID we can access it directly too.
     * 

     */
    public void postRunnerItemOutputs(com.clarifai.grpc.api.PostRunnerItemOutputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostRunnerItemOutputsMethod(), responseObserver);
    }

    /**
     * 
     * This maintains a single request for asking the API if there is any work to be done, processing
     * it and streaming back results.
     * To do that first handshake the MultiRunnerItemOutputResponse will have RUNNER_STREAM_START
     * status filled in so that the API knows to respond with a MultiRunnerItemResponse.
     * For now there will only be one of those if the model prediction only has one request.
     * NOTE(zeiler): downside of this is you can't use HTTP REST requests to do runner work.
     * 

     */
    public io.grpc.stub.StreamObserver processRunnerItems(
        io.grpc.stub.StreamObserver responseObserver) {
      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getProcessRunnerItemsMethod(), responseObserver);
    }

    /**
     * 
     * Get the training time estimate based off train request and estimated input count.
     * 

     */
    public void postModelVersionsTrainingTimeEstimate(com.clarifai.grpc.api.PostModelVersionsTrainingTimeEstimateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPostModelVersionsTrainingTimeEstimateMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getListConceptRelationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListConceptRelationsRequest,
                com.clarifai.grpc.api.MultiConceptRelationResponse>(
                  this, METHODID_LIST_CONCEPT_RELATIONS)))
          .addMethod(
            getPostConceptRelationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostConceptRelationsRequest,
                com.clarifai.grpc.api.MultiConceptRelationResponse>(
                  this, METHODID_POST_CONCEPT_RELATIONS)))
          .addMethod(
            getDeleteConceptRelationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteConceptRelationsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_CONCEPT_RELATIONS)))
          .addMethod(
            getGetConceptCountsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetConceptCountsRequest,
                com.clarifai.grpc.api.MultiConceptCountResponse>(
                  this, METHODID_GET_CONCEPT_COUNTS)))
          .addMethod(
            getGetConceptMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetConceptRequest,
                com.clarifai.grpc.api.SingleConceptResponse>(
                  this, METHODID_GET_CONCEPT)))
          .addMethod(
            getListConceptsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListConceptsRequest,
                com.clarifai.grpc.api.MultiConceptResponse>(
                  this, METHODID_LIST_CONCEPTS)))
          .addMethod(
            getListModelConceptsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelConceptsRequest,
                com.clarifai.grpc.api.MultiConceptResponse>(
                  this, METHODID_LIST_MODEL_CONCEPTS)))
          .addMethod(
            getPostConceptsSearchesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostConceptsSearchesRequest,
                com.clarifai.grpc.api.MultiConceptResponse>(
                  this, METHODID_POST_CONCEPTS_SEARCHES)))
          .addMethod(
            getPostConceptsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostConceptsRequest,
                com.clarifai.grpc.api.MultiConceptResponse>(
                  this, METHODID_POST_CONCEPTS)))
          .addMethod(
            getPatchConceptsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchConceptsRequest,
                com.clarifai.grpc.api.MultiConceptResponse>(
                  this, METHODID_PATCH_CONCEPTS)))
          .addMethod(
            getGetConceptLanguageMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetConceptLanguageRequest,
                com.clarifai.grpc.api.SingleConceptLanguageResponse>(
                  this, METHODID_GET_CONCEPT_LANGUAGE)))
          .addMethod(
            getListConceptLanguagesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListConceptLanguagesRequest,
                com.clarifai.grpc.api.MultiConceptLanguageResponse>(
                  this, METHODID_LIST_CONCEPT_LANGUAGES)))
          .addMethod(
            getPostConceptLanguagesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostConceptLanguagesRequest,
                com.clarifai.grpc.api.MultiConceptLanguageResponse>(
                  this, METHODID_POST_CONCEPT_LANGUAGES)))
          .addMethod(
            getPatchConceptLanguagesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchConceptLanguagesRequest,
                com.clarifai.grpc.api.MultiConceptLanguageResponse>(
                  this, METHODID_PATCH_CONCEPT_LANGUAGES)))
          .addMethod(
            getListKnowledgeGraphsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListKnowledgeGraphsRequest,
                com.clarifai.grpc.api.MultiKnowledgeGraphResponse>(
                  this, METHODID_LIST_KNOWLEDGE_GRAPHS)))
          .addMethod(
            getPostKnowledgeGraphsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostKnowledgeGraphsRequest,
                com.clarifai.grpc.api.MultiKnowledgeGraphResponse>(
                  this, METHODID_POST_KNOWLEDGE_GRAPHS)))
          .addMethod(
            getPostConceptMappingJobsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostConceptMappingJobsRequest,
                com.clarifai.grpc.api.MultiConceptMappingJobResponse>(
                  this, METHODID_POST_CONCEPT_MAPPING_JOBS)))
          .addMethod(
            getGetAnnotationMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetAnnotationRequest,
                com.clarifai.grpc.api.SingleAnnotationResponse>(
                  this, METHODID_GET_ANNOTATION)))
          .addMethod(
            getListAnnotationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAnnotationsRequest,
                com.clarifai.grpc.api.MultiAnnotationResponse>(
                  this, METHODID_LIST_ANNOTATIONS)))
          .addMethod(
            getPostAnnotationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAnnotationsRequest,
                com.clarifai.grpc.api.MultiAnnotationResponse>(
                  this, METHODID_POST_ANNOTATIONS)))
          .addMethod(
            getPatchAnnotationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchAnnotationsRequest,
                com.clarifai.grpc.api.MultiAnnotationResponse>(
                  this, METHODID_PATCH_ANNOTATIONS)))
          .addMethod(
            getPatchAnnotationsStatusMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchAnnotationsStatusRequest,
                com.clarifai.grpc.api.PatchAnnotationsStatusResponse>(
                  this, METHODID_PATCH_ANNOTATIONS_STATUS)))
          .addMethod(
            getDeleteAnnotationMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteAnnotationRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_ANNOTATION)))
          .addMethod(
            getDeleteAnnotationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteAnnotationsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_ANNOTATIONS)))
          .addMethod(
            getPatchAnnotationsSearchesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchAnnotationsSearchesRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_PATCH_ANNOTATIONS_SEARCHES)))
          .addMethod(
            getPostAnnotationsSearchesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAnnotationsSearchesRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_POST_ANNOTATIONS_SEARCHES)))
          .addMethod(
            getListAnnotationWorkersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAnnotationWorkersRequest,
                com.clarifai.grpc.api.MultiWorkerResponse>(
                  this, METHODID_LIST_ANNOTATION_WORKERS)))
          .addMethod(
            getGetInputCountMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetInputCountRequest,
                com.clarifai.grpc.api.SingleInputCountResponse>(
                  this, METHODID_GET_INPUT_COUNT)))
          .addMethod(
            getStreamInputsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.StreamInputsRequest,
                com.clarifai.grpc.api.MultiInputResponse>(
                  this, METHODID_STREAM_INPUTS)))
          .addMethod(
            getGetInputSamplesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetInputSamplesRequest,
                com.clarifai.grpc.api.MultiInputAnnotationResponse>(
                  this, METHODID_GET_INPUT_SAMPLES)))
          .addMethod(
            getGetInputMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetInputRequest,
                com.clarifai.grpc.api.SingleInputResponse>(
                  this, METHODID_GET_INPUT)))
          .addMethod(
            getGetInputVideoManifestMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetVideoManifestRequest,
                com.clarifai.grpc.api.GetVideoManifestResponse>(
                  this, METHODID_GET_INPUT_VIDEO_MANIFEST)))
          .addMethod(
            getListInputsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListInputsRequest,
                com.clarifai.grpc.api.MultiInputResponse>(
                  this, METHODID_LIST_INPUTS)))
          .addMethod(
            getPostInputsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostInputsRequest,
                com.clarifai.grpc.api.MultiInputResponse>(
                  this, METHODID_POST_INPUTS)))
          .addMethod(
            getPatchInputsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchInputsRequest,
                com.clarifai.grpc.api.MultiInputResponse>(
                  this, METHODID_PATCH_INPUTS)))
          .addMethod(
            getDeleteInputMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteInputRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_INPUT)))
          .addMethod(
            getDeleteInputsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteInputsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_INPUTS)))
          .addMethod(
            getPatchInputsSearchesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchInputsSearchesRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_PATCH_INPUTS_SEARCHES)))
          .addMethod(
            getPostInputsSearchesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostInputsSearchesRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_POST_INPUTS_SEARCHES)))
          .addMethod(
            getPostModelOutputsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelOutputsRequest,
                com.clarifai.grpc.api.MultiOutputResponse>(
                  this, METHODID_POST_MODEL_OUTPUTS)))
          .addMethod(
            getGenerateModelOutputsMethod(),
            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelOutputsRequest,
                com.clarifai.grpc.api.MultiOutputResponse>(
                  this, METHODID_GENERATE_MODEL_OUTPUTS)))
          .addMethod(
            getStreamModelOutputsMethod(),
            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelOutputsRequest,
                com.clarifai.grpc.api.MultiOutputResponse>(
                  this, METHODID_STREAM_MODEL_OUTPUTS)))
          .addMethod(
            getListDatasetsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListDatasetsRequest,
                com.clarifai.grpc.api.MultiDatasetResponse>(
                  this, METHODID_LIST_DATASETS)))
          .addMethod(
            getGetDatasetMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetDatasetRequest,
                com.clarifai.grpc.api.SingleDatasetResponse>(
                  this, METHODID_GET_DATASET)))
          .addMethod(
            getPostDatasetsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostDatasetsRequest,
                com.clarifai.grpc.api.MultiDatasetResponse>(
                  this, METHODID_POST_DATASETS)))
          .addMethod(
            getPatchDatasetsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchDatasetsRequest,
                com.clarifai.grpc.api.MultiDatasetResponse>(
                  this, METHODID_PATCH_DATASETS)))
          .addMethod(
            getDeleteDatasetsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteDatasetsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_DATASETS)))
          .addMethod(
            getListDatasetInputsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListDatasetInputsRequest,
                com.clarifai.grpc.api.MultiDatasetInputResponse>(
                  this, METHODID_LIST_DATASET_INPUTS)))
          .addMethod(
            getGetDatasetInputMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetDatasetInputRequest,
                com.clarifai.grpc.api.SingleDatasetInputResponse>(
                  this, METHODID_GET_DATASET_INPUT)))
          .addMethod(
            getPostDatasetInputsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostDatasetInputsRequest,
                com.clarifai.grpc.api.MultiDatasetInputResponse>(
                  this, METHODID_POST_DATASET_INPUTS)))
          .addMethod(
            getDeleteDatasetInputsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteDatasetInputsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_DATASET_INPUTS)))
          .addMethod(
            getListDatasetVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListDatasetVersionsRequest,
                com.clarifai.grpc.api.MultiDatasetVersionResponse>(
                  this, METHODID_LIST_DATASET_VERSIONS)))
          .addMethod(
            getGetDatasetVersionMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetDatasetVersionRequest,
                com.clarifai.grpc.api.SingleDatasetVersionResponse>(
                  this, METHODID_GET_DATASET_VERSION)))
          .addMethod(
            getListDatasetVersionMetricsGroupsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListDatasetVersionMetricsGroupsRequest,
                com.clarifai.grpc.api.MultiDatasetVersionMetricsGroupResponse>(
                  this, METHODID_LIST_DATASET_VERSION_METRICS_GROUPS)))
          .addMethod(
            getPostDatasetVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostDatasetVersionsRequest,
                com.clarifai.grpc.api.MultiDatasetVersionResponse>(
                  this, METHODID_POST_DATASET_VERSIONS)))
          .addMethod(
            getPatchDatasetVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchDatasetVersionsRequest,
                com.clarifai.grpc.api.MultiDatasetVersionResponse>(
                  this, METHODID_PATCH_DATASET_VERSIONS)))
          .addMethod(
            getDeleteDatasetVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteDatasetVersionsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_DATASET_VERSIONS)))
          .addMethod(
            getPutDatasetVersionExportsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PutDatasetVersionExportsRequest,
                com.clarifai.grpc.api.MultiDatasetVersionExportResponse>(
                  this, METHODID_PUT_DATASET_VERSION_EXPORTS)))
          .addMethod(
            getGetModelTypeMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelTypeRequest,
                com.clarifai.grpc.api.SingleModelTypeResponse>(
                  this, METHODID_GET_MODEL_TYPE)))
          .addMethod(
            getListOpenSourceLicensesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListOpenSourceLicensesRequest,
                com.clarifai.grpc.api.ListOpenSourceLicensesResponse>(
                  this, METHODID_LIST_OPEN_SOURCE_LICENSES)))
          .addMethod(
            getListModelTypesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelTypesRequest,
                com.clarifai.grpc.api.MultiModelTypeResponse>(
                  this, METHODID_LIST_MODEL_TYPES)))
          .addMethod(
            getGetModelMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelRequest,
                com.clarifai.grpc.api.SingleModelResponse>(
                  this, METHODID_GET_MODEL)))
          .addMethod(
            getGetModelOutputInfoMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelRequest,
                com.clarifai.grpc.api.SingleModelResponse>(
                  this, METHODID_GET_MODEL_OUTPUT_INFO)))
          .addMethod(
            getListModelsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelsRequest,
                com.clarifai.grpc.api.MultiModelResponse>(
                  this, METHODID_LIST_MODELS)))
          .addMethod(
            getGetResourceCountsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetResourceCountsRequest,
                com.clarifai.grpc.api.GetResourceCountsResponse>(
                  this, METHODID_GET_RESOURCE_COUNTS)))
          .addMethod(
            getPostModelsSearchesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelsSearchesRequest,
                com.clarifai.grpc.api.MultiModelResponse>(
                  this, METHODID_POST_MODELS_SEARCHES)))
          .addMethod(
            getPostModelsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelsRequest,
                com.clarifai.grpc.api.SingleModelResponse>(
                  this, METHODID_POST_MODELS)))
          .addMethod(
            getPatchModelsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelsRequest,
                com.clarifai.grpc.api.MultiModelResponse>(
                  this, METHODID_PATCH_MODELS)))
          .addMethod(
            getPatchModelIdsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelIdsRequest,
                com.clarifai.grpc.api.MultiModelResponse>(
                  this, METHODID_PATCH_MODEL_IDS)))
          .addMethod(
            getDeleteModelMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteModelRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_MODEL)))
          .addMethod(
            getDeleteModelsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteModelsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_MODELS)))
          .addMethod(
            getPatchModelCheckConsentsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelCheckConsentsRequest,
                com.clarifai.grpc.api.MultiModelCheckConsentResponse>(
                  this, METHODID_PATCH_MODEL_CHECK_CONSENTS)))
          .addMethod(
            getPatchModelToolkitsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelToolkitsRequest,
                com.clarifai.grpc.api.MultiModelToolkitResponse>(
                  this, METHODID_PATCH_MODEL_TOOLKITS)))
          .addMethod(
            getPatchModelUseCasesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelUseCasesRequest,
                com.clarifai.grpc.api.MultiModelUseCaseResponse>(
                  this, METHODID_PATCH_MODEL_USE_CASES)))
          .addMethod(
            getPatchModelLanguagesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelLanguagesRequest,
                com.clarifai.grpc.api.MultiModelLanguageResponse>(
                  this, METHODID_PATCH_MODEL_LANGUAGES)))
          .addMethod(
            getListModelInputsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelInputsRequest,
                com.clarifai.grpc.api.MultiInputResponse>(
                  this, METHODID_LIST_MODEL_INPUTS)))
          .addMethod(
            getGetModelVersionMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelVersionRequest,
                com.clarifai.grpc.api.SingleModelVersionResponse>(
                  this, METHODID_GET_MODEL_VERSION)))
          .addMethod(
            getListModelVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelVersionsRequest,
                com.clarifai.grpc.api.MultiModelVersionResponse>(
                  this, METHODID_LIST_MODEL_VERSIONS)))
          .addMethod(
            getPostWorkflowVersionsUnPublishMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostWorkflowVersionsUnPublishRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_POST_WORKFLOW_VERSIONS_UN_PUBLISH)))
          .addMethod(
            getPostWorkflowVersionsPublishMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostWorkflowVersionsPublishRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_POST_WORKFLOW_VERSIONS_PUBLISH)))
          .addMethod(
            getPostModelVersionsPublishMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelVersionsPublishRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_POST_MODEL_VERSIONS_PUBLISH)))
          .addMethod(
            getPostModelVersionsUnPublishMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelVersionsUnPublishRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_POST_MODEL_VERSIONS_UN_PUBLISH)))
          .addMethod(
            getPostModelVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelVersionsRequest,
                com.clarifai.grpc.api.SingleModelResponse>(
                  this, METHODID_POST_MODEL_VERSIONS)))
          .addMethod(
            getPatchModelVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModelVersionsRequest,
                com.clarifai.grpc.api.MultiModelVersionResponse>(
                  this, METHODID_PATCH_MODEL_VERSIONS)))
          .addMethod(
            getDeleteModelVersionMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteModelVersionRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_MODEL_VERSION)))
          .addMethod(
            getPostModelVersionsUploadMethod(),
            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelVersionsUploadRequest,
                com.clarifai.grpc.api.PostModelVersionsUploadResponse>(
                  this, METHODID_POST_MODEL_VERSIONS_UPLOAD)))
          .addMethod(
            getPutModelVersionExportsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PutModelVersionExportsRequest,
                com.clarifai.grpc.api.SingleModelVersionExportResponse>(
                  this, METHODID_PUT_MODEL_VERSION_EXPORTS)))
          .addMethod(
            getGetModelVersionExportMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelVersionExportRequest,
                com.clarifai.grpc.api.SingleModelVersionExportResponse>(
                  this, METHODID_GET_MODEL_VERSION_EXPORT)))
          .addMethod(
            getGetModelVersionMetricsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelVersionMetricsRequest,
                com.clarifai.grpc.api.SingleModelVersionResponse>(
                  this, METHODID_GET_MODEL_VERSION_METRICS)))
          .addMethod(
            getPostModelVersionMetricsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelVersionMetricsRequest,
                com.clarifai.grpc.api.SingleModelVersionResponse>(
                  this, METHODID_POST_MODEL_VERSION_METRICS)))
          .addMethod(
            getPostModelVersionEvaluationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelVersionEvaluationsRequest,
                com.clarifai.grpc.api.MultiEvalMetricsResponse>(
                  this, METHODID_POST_MODEL_VERSION_EVALUATIONS)))
          .addMethod(
            getListModelVersionEvaluationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelVersionEvaluationsRequest,
                com.clarifai.grpc.api.MultiEvalMetricsResponse>(
                  this, METHODID_LIST_MODEL_VERSION_EVALUATIONS)))
          .addMethod(
            getGetModelVersionEvaluationMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelVersionEvaluationRequest,
                com.clarifai.grpc.api.SingleEvalMetricsResponse>(
                  this, METHODID_GET_MODEL_VERSION_EVALUATION)))
          .addMethod(
            getPostEvaluationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostEvaluationsRequest,
                com.clarifai.grpc.api.MultiEvalMetricsResponse>(
                  this, METHODID_POST_EVALUATIONS)))
          .addMethod(
            getListEvaluationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListEvaluationsRequest,
                com.clarifai.grpc.api.MultiEvalMetricsResponse>(
                  this, METHODID_LIST_EVALUATIONS)))
          .addMethod(
            getGetEvaluationMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetEvaluationRequest,
                com.clarifai.grpc.api.SingleEvalMetricsResponse>(
                  this, METHODID_GET_EVALUATION)))
          .addMethod(
            getListModelReferencesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelReferencesRequest,
                com.clarifai.grpc.api.MultiModelReferenceResponse>(
                  this, METHODID_LIST_MODEL_REFERENCES)))
          .addMethod(
            getGetModelVersionInputExampleMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModelVersionInputExampleRequest,
                com.clarifai.grpc.api.SingleModelVersionInputExampleResponse>(
                  this, METHODID_GET_MODEL_VERSION_INPUT_EXAMPLE)))
          .addMethod(
            getListModelVersionInputExamplesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModelVersionInputExamplesRequest,
                com.clarifai.grpc.api.MultiModelVersionInputExampleResponse>(
                  this, METHODID_LIST_MODEL_VERSION_INPUT_EXAMPLES)))
          .addMethod(
            getGetWorkflowMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetWorkflowRequest,
                com.clarifai.grpc.api.SingleWorkflowResponse>(
                  this, METHODID_GET_WORKFLOW)))
          .addMethod(
            getListWorkflowsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListWorkflowsRequest,
                com.clarifai.grpc.api.MultiWorkflowResponse>(
                  this, METHODID_LIST_WORKFLOWS)))
          .addMethod(
            getPostWorkflowsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostWorkflowsRequest,
                com.clarifai.grpc.api.MultiWorkflowResponse>(
                  this, METHODID_POST_WORKFLOWS)))
          .addMethod(
            getPatchWorkflowsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchWorkflowsRequest,
                com.clarifai.grpc.api.MultiWorkflowResponse>(
                  this, METHODID_PATCH_WORKFLOWS)))
          .addMethod(
            getPatchWorkflowIdsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchWorkflowIdsRequest,
                com.clarifai.grpc.api.MultiWorkflowResponse>(
                  this, METHODID_PATCH_WORKFLOW_IDS)))
          .addMethod(
            getDeleteWorkflowMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteWorkflowRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_WORKFLOW)))
          .addMethod(
            getDeleteWorkflowsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteWorkflowsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_WORKFLOWS)))
          .addMethod(
            getPostWorkflowResultsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostWorkflowResultsRequest,
                com.clarifai.grpc.api.PostWorkflowResultsResponse>(
                  this, METHODID_POST_WORKFLOW_RESULTS)))
          .addMethod(
            getPostWorkflowResultsSimilarityMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostWorkflowResultsSimilarityRequest,
                com.clarifai.grpc.api.PostWorkflowResultsSimilarityResponse>(
                  this, METHODID_POST_WORKFLOW_RESULTS_SIMILARITY)))
          .addMethod(
            getListWorkflowVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListWorkflowVersionsRequest,
                com.clarifai.grpc.api.MultiWorkflowVersionResponse>(
                  this, METHODID_LIST_WORKFLOW_VERSIONS)))
          .addMethod(
            getGetWorkflowVersionMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetWorkflowVersionRequest,
                com.clarifai.grpc.api.SingleWorkflowVersionResponse>(
                  this, METHODID_GET_WORKFLOW_VERSION)))
          .addMethod(
            getDeleteWorkflowVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteWorkflowVersionsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_WORKFLOW_VERSIONS)))
          .addMethod(
            getPatchWorkflowVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchWorkflowVersionsRequest,
                com.clarifai.grpc.api.MultiWorkflowVersionResponse>(
                  this, METHODID_PATCH_WORKFLOW_VERSIONS)))
          .addMethod(
            getGetKeyMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetKeyRequest,
                com.clarifai.grpc.api.SingleKeyResponse>(
                  this, METHODID_GET_KEY)))
          .addMethod(
            getListKeysMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListKeysRequest,
                com.clarifai.grpc.api.MultiKeyResponse>(
                  this, METHODID_LIST_KEYS)))
          .addMethod(
            getListAppKeysMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAppKeysRequest,
                com.clarifai.grpc.api.MultiKeyResponse>(
                  this, METHODID_LIST_APP_KEYS)))
          .addMethod(
            getDeleteKeyMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteKeyRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_KEY)))
          .addMethod(
            getPostKeysMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostKeysRequest,
                com.clarifai.grpc.api.MultiKeyResponse>(
                  this, METHODID_POST_KEYS)))
          .addMethod(
            getPatchKeysMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchKeysRequest,
                com.clarifai.grpc.api.MultiKeyResponse>(
                  this, METHODID_PATCH_KEYS)))
          .addMethod(
            getMyScopesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.MyScopesRequest,
                com.clarifai.grpc.api.MultiScopeResponse>(
                  this, METHODID_MY_SCOPES)))
          .addMethod(
            getMyScopesUserMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.MyScopesUserRequest,
                com.clarifai.grpc.api.MultiScopeUserResponse>(
                  this, METHODID_MY_SCOPES_USER)))
          .addMethod(
            getMyScopesRootMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.MyScopesRootRequest,
                com.clarifai.grpc.api.MultiScopeRootResponse>(
                  this, METHODID_MY_SCOPES_ROOT)))
          .addMethod(
            getListScopesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListScopesRequest,
                com.clarifai.grpc.api.MultiScopeDepsResponse>(
                  this, METHODID_LIST_SCOPES)))
          .addMethod(
            getGetAppMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetAppRequest,
                com.clarifai.grpc.api.SingleAppResponse>(
                  this, METHODID_GET_APP)))
          .addMethod(
            getListAppsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAppsRequest,
                com.clarifai.grpc.api.MultiAppResponse>(
                  this, METHODID_LIST_APPS)))
          .addMethod(
            getDeleteAppMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteAppRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_APP)))
          .addMethod(
            getPostAppsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAppsRequest,
                com.clarifai.grpc.api.MultiAppResponse>(
                  this, METHODID_POST_APPS)))
          .addMethod(
            getPatchAppsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchAppsRequest,
                com.clarifai.grpc.api.MultiAppResponse>(
                  this, METHODID_PATCH_APPS)))
          .addMethod(
            getPatchAppsIdsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchAppsIdsRequest,
                com.clarifai.grpc.api.MultiAppResponse>(
                  this, METHODID_PATCH_APPS_IDS)))
          .addMethod(
            getPatchAppMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchAppRequest,
                com.clarifai.grpc.api.SingleAppResponse>(
                  this, METHODID_PATCH_APP)))
          .addMethod(
            getPostAppsSearchesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAppsSearchesRequest,
                com.clarifai.grpc.api.MultiAppResponse>(
                  this, METHODID_POST_APPS_SEARCHES)))
          .addMethod(
            getGetUserMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetUserRequest,
                com.clarifai.grpc.api.SingleUserResponse>(
                  this, METHODID_GET_USER)))
          .addMethod(
            getPostValidatePasswordMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostValidatePasswordRequest,
                com.clarifai.grpc.api.SinglePasswordValidationResponse>(
                  this, METHODID_POST_VALIDATE_PASSWORD)))
          .addMethod(
            getGetSearchMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetSearchRequest,
                com.clarifai.grpc.api.SingleSearchResponse>(
                  this, METHODID_GET_SEARCH)))
          .addMethod(
            getListSearchesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListSearchesRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_LIST_SEARCHES)))
          .addMethod(
            getPatchSearchesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchSearchesRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_PATCH_SEARCHES)))
          .addMethod(
            getPostSearchesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostSearchesRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_POST_SEARCHES)))
          .addMethod(
            getPostSearchesByIDMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostSearchesByIDRequest,
                com.clarifai.grpc.api.MultiSearchResponse>(
                  this, METHODID_POST_SEARCHES_BY_ID)))
          .addMethod(
            getPostAnnotationSearchMetricsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAnnotationSearchMetricsRequest,
                com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse>(
                  this, METHODID_POST_ANNOTATION_SEARCH_METRICS)))
          .addMethod(
            getGetAnnotationSearchMetricsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetAnnotationSearchMetricsRequest,
                com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse>(
                  this, METHODID_GET_ANNOTATION_SEARCH_METRICS)))
          .addMethod(
            getListAnnotationSearchMetricsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAnnotationSearchMetricsRequest,
                com.clarifai.grpc.api.MultiAnnotationSearchMetricsResponse>(
                  this, METHODID_LIST_ANNOTATION_SEARCH_METRICS)))
          .addMethod(
            getDeleteAnnotationSearchMetricsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteAnnotationSearchMetricsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_ANNOTATION_SEARCH_METRICS)))
          .addMethod(
            getDeleteSearchMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteSearchRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_SEARCH)))
          .addMethod(
            getListAnnotationFiltersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAnnotationFiltersRequest,
                com.clarifai.grpc.api.MultiAnnotationFilterResponse>(
                  this, METHODID_LIST_ANNOTATION_FILTERS)))
          .addMethod(
            getGetAnnotationFilterMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetAnnotationFilterRequest,
                com.clarifai.grpc.api.SingleAnnotationFilterResponse>(
                  this, METHODID_GET_ANNOTATION_FILTER)))
          .addMethod(
            getPostAnnotationFiltersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAnnotationFiltersRequest,
                com.clarifai.grpc.api.MultiAnnotationFilterResponse>(
                  this, METHODID_POST_ANNOTATION_FILTERS)))
          .addMethod(
            getPatchAnnotationFiltersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchAnnotationFiltersRequest,
                com.clarifai.grpc.api.MultiAnnotationFilterResponse>(
                  this, METHODID_PATCH_ANNOTATION_FILTERS)))
          .addMethod(
            getDeleteAnnotationFiltersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteAnnotationFiltersRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_ANNOTATION_FILTERS)))
          .addMethod(
            getListStatusCodesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListStatusCodesRequest,
                com.clarifai.grpc.api.MultiStatusCodeResponse>(
                  this, METHODID_LIST_STATUS_CODES)))
          .addMethod(
            getGetStatusCodeMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetStatusCodeRequest,
                com.clarifai.grpc.api.SingleStatusCodeResponse>(
                  this, METHODID_GET_STATUS_CODE)))
          .addMethod(
            getListCollaboratorsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListCollaboratorsRequest,
                com.clarifai.grpc.api.MultiCollaboratorsResponse>(
                  this, METHODID_LIST_COLLABORATORS)))
          .addMethod(
            getPostCollaboratorsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostCollaboratorsRequest,
                com.clarifai.grpc.api.MultiCollaboratorsResponse>(
                  this, METHODID_POST_COLLABORATORS)))
          .addMethod(
            getPatchCollaboratorsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchCollaboratorsRequest,
                com.clarifai.grpc.api.MultiCollaboratorsResponse>(
                  this, METHODID_PATCH_COLLABORATORS)))
          .addMethod(
            getDeleteCollaboratorsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteCollaboratorsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_COLLABORATORS)))
          .addMethod(
            getListCollaborationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListCollaborationsRequest,
                com.clarifai.grpc.api.MultiCollaborationsResponse>(
                  this, METHODID_LIST_COLLABORATIONS)))
          .addMethod(
            getPostAppDuplicationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostAppDuplicationsRequest,
                com.clarifai.grpc.api.MultiAppDuplicationsResponse>(
                  this, METHODID_POST_APP_DUPLICATIONS)))
          .addMethod(
            getListAppDuplicationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListAppDuplicationsRequest,
                com.clarifai.grpc.api.MultiAppDuplicationsResponse>(
                  this, METHODID_LIST_APP_DUPLICATIONS)))
          .addMethod(
            getGetAppDuplicationMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetAppDuplicationRequest,
                com.clarifai.grpc.api.SingleAppDuplicationResponse>(
                  this, METHODID_GET_APP_DUPLICATION)))
          .addMethod(
            getPostTasksMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostTasksRequest,
                com.clarifai.grpc.api.MultiTaskResponse>(
                  this, METHODID_POST_TASKS)))
          .addMethod(
            getGetTaskAnnotationCountMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetTaskCountRequest,
                com.clarifai.grpc.api.SingleTaskCountResponse>(
                  this, METHODID_GET_TASK_ANNOTATION_COUNT)))
          .addMethod(
            getGetTaskInputCountMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetTaskCountRequest,
                com.clarifai.grpc.api.SingleTaskCountResponse>(
                  this, METHODID_GET_TASK_INPUT_COUNT)))
          .addMethod(
            getGetTaskMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetTaskRequest,
                com.clarifai.grpc.api.SingleTaskResponse>(
                  this, METHODID_GET_TASK)))
          .addMethod(
            getListTasksMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListTasksRequest,
                com.clarifai.grpc.api.MultiTaskResponse>(
                  this, METHODID_LIST_TASKS)))
          .addMethod(
            getPatchTasksMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchTasksRequest,
                com.clarifai.grpc.api.MultiTaskResponse>(
                  this, METHODID_PATCH_TASKS)))
          .addMethod(
            getDeleteTasksMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteTasksRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_TASKS)))
          .addMethod(
            getPostLabelOrdersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostLabelOrdersRequest,
                com.clarifai.grpc.api.MultiLabelOrderResponse>(
                  this, METHODID_POST_LABEL_ORDERS)))
          .addMethod(
            getGetLabelOrderMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetLabelOrderRequest,
                com.clarifai.grpc.api.SingleLabelOrderResponse>(
                  this, METHODID_GET_LABEL_ORDER)))
          .addMethod(
            getListLabelOrdersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListLabelOrdersRequest,
                com.clarifai.grpc.api.MultiLabelOrderResponse>(
                  this, METHODID_LIST_LABEL_ORDERS)))
          .addMethod(
            getPatchLabelOrdersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchLabelOrdersRequest,
                com.clarifai.grpc.api.MultiLabelOrderResponse>(
                  this, METHODID_PATCH_LABEL_ORDERS)))
          .addMethod(
            getDeleteLabelOrdersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteLabelOrdersRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_LABEL_ORDERS)))
          .addMethod(
            getPostCollectorsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostCollectorsRequest,
                com.clarifai.grpc.api.MultiCollectorResponse>(
                  this, METHODID_POST_COLLECTORS)))
          .addMethod(
            getGetCollectorMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetCollectorRequest,
                com.clarifai.grpc.api.SingleCollectorResponse>(
                  this, METHODID_GET_COLLECTOR)))
          .addMethod(
            getListCollectorsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListCollectorsRequest,
                com.clarifai.grpc.api.MultiCollectorResponse>(
                  this, METHODID_LIST_COLLECTORS)))
          .addMethod(
            getPatchCollectorsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchCollectorsRequest,
                com.clarifai.grpc.api.MultiCollectorResponse>(
                  this, METHODID_PATCH_COLLECTORS)))
          .addMethod(
            getDeleteCollectorsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteCollectorsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_COLLECTORS)))
          .addMethod(
            getPostStatValuesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostStatValuesRequest,
                com.clarifai.grpc.api.MultiStatValueResponse>(
                  this, METHODID_POST_STAT_VALUES)))
          .addMethod(
            getPostStatValuesAggregateMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostStatValuesAggregateRequest,
                com.clarifai.grpc.api.MultiStatValueAggregateResponse>(
                  this, METHODID_POST_STAT_VALUES_AGGREGATE)))
          .addMethod(
            getPostTrendingMetricsViewMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostTrendingMetricsViewRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_POST_TRENDING_METRICS_VIEW)))
          .addMethod(
            getListTrendingMetricsViewsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListTrendingMetricsViewsRequest,
                com.clarifai.grpc.api.MultiTrendingMetricsViewResponse>(
                  this, METHODID_LIST_TRENDING_METRICS_VIEWS)))
          .addMethod(
            getGetModuleMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModuleRequest,
                com.clarifai.grpc.api.SingleModuleResponse>(
                  this, METHODID_GET_MODULE)))
          .addMethod(
            getListModulesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModulesRequest,
                com.clarifai.grpc.api.MultiModuleResponse>(
                  this, METHODID_LIST_MODULES)))
          .addMethod(
            getPostModulesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModulesRequest,
                com.clarifai.grpc.api.MultiModuleResponse>(
                  this, METHODID_POST_MODULES)))
          .addMethod(
            getPatchModulesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModulesRequest,
                com.clarifai.grpc.api.MultiModuleResponse>(
                  this, METHODID_PATCH_MODULES)))
          .addMethod(
            getDeleteModulesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteModulesRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_MODULES)))
          .addMethod(
            getGetModuleVersionMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModuleVersionRequest,
                com.clarifai.grpc.api.SingleModuleVersionResponse>(
                  this, METHODID_GET_MODULE_VERSION)))
          .addMethod(
            getListModuleVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListModuleVersionsRequest,
                com.clarifai.grpc.api.MultiModuleVersionResponse>(
                  this, METHODID_LIST_MODULE_VERSIONS)))
          .addMethod(
            getPostModuleVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModuleVersionsRequest,
                com.clarifai.grpc.api.MultiModuleVersionResponse>(
                  this, METHODID_POST_MODULE_VERSIONS)))
          .addMethod(
            getPatchModuleVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PatchModuleVersionsRequest,
                com.clarifai.grpc.api.MultiModuleVersionResponse>(
                  this, METHODID_PATCH_MODULE_VERSIONS)))
          .addMethod(
            getDeleteModuleVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteModuleVersionsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_MODULE_VERSIONS)))
          .addMethod(
            getGetModuleVersionUsageCountMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetModuleVersionUsageCountRequest,
                com.clarifai.grpc.api.SingleModuleVersionUsageCountResponse>(
                  this, METHODID_GET_MODULE_VERSION_USAGE_COUNT)))
          .addMethod(
            getGetInstalledModuleVersionMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetInstalledModuleVersionRequest,
                com.clarifai.grpc.api.SingleInstalledModuleVersionResponse>(
                  this, METHODID_GET_INSTALLED_MODULE_VERSION)))
          .addMethod(
            getListInstalledModuleVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListInstalledModuleVersionsRequest,
                com.clarifai.grpc.api.MultiInstalledModuleVersionResponse>(
                  this, METHODID_LIST_INSTALLED_MODULE_VERSIONS)))
          .addMethod(
            getPostInstalledModuleVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostInstalledModuleVersionsRequest,
                com.clarifai.grpc.api.MultiInstalledModuleVersionResponse>(
                  this, METHODID_POST_INSTALLED_MODULE_VERSIONS)))
          .addMethod(
            getDeleteInstalledModuleVersionsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteInstalledModuleVersionsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_INSTALLED_MODULE_VERSIONS)))
          .addMethod(
            getPostInstalledModuleVersionsKeyMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostInstalledModuleVersionsKeyRequest,
                com.clarifai.grpc.api.SingleKeyResponse>(
                  this, METHODID_POST_INSTALLED_MODULE_VERSIONS_KEY)))
          .addMethod(
            getPostBulkOperationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostBulkOperationsRequest,
                com.clarifai.grpc.api.MultiBulkOperationsResponse>(
                  this, METHODID_POST_BULK_OPERATIONS)))
          .addMethod(
            getListBulkOperationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListBulkOperationsRequest,
                com.clarifai.grpc.api.MultiBulkOperationsResponse>(
                  this, METHODID_LIST_BULK_OPERATIONS)))
          .addMethod(
            getGetBulkOperationMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetBulkOperationRequest,
                com.clarifai.grpc.api.SingleBulkOperationsResponse>(
                  this, METHODID_GET_BULK_OPERATION)))
          .addMethod(
            getCancelBulkOperationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.CancelBulkOperationRequest,
                com.clarifai.grpc.api.MultiBulkOperationsResponse>(
                  this, METHODID_CANCEL_BULK_OPERATIONS)))
          .addMethod(
            getDeleteBulkOperationsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteBulkOperationRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_BULK_OPERATIONS)))
          .addMethod(
            getListNextTaskAssignmentsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListNextTaskAssignmentsRequest,
                com.clarifai.grpc.api.MultiInputResponse>(
                  this, METHODID_LIST_NEXT_TASK_ASSIGNMENTS)))
          .addMethod(
            getPutTaskAssignmentsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PutTaskAssignmentsRequest,
                com.clarifai.grpc.api.MultiTaskAssignmentResponse>(
                  this, METHODID_PUT_TASK_ASSIGNMENTS)))
          .addMethod(
            getListInputsAddJobsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListInputsAddJobsRequest,
                com.clarifai.grpc.api.MultiInputsAddJobResponse>(
                  this, METHODID_LIST_INPUTS_ADD_JOBS)))
          .addMethod(
            getGetInputsAddJobMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetInputsAddJobRequest,
                com.clarifai.grpc.api.SingleInputsAddJobResponse>(
                  this, METHODID_GET_INPUTS_ADD_JOB)))
          .addMethod(
            getCancelInputsAddJobMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.CancelInputsAddJobRequest,
                com.clarifai.grpc.api.SingleInputsAddJobResponse>(
                  this, METHODID_CANCEL_INPUTS_ADD_JOB)))
          .addMethod(
            getPostUploadsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostUploadsRequest,
                com.clarifai.grpc.api.MultiUploadResponse>(
                  this, METHODID_POST_UPLOADS)))
          .addMethod(
            getPutUploadContentPartsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PutUploadContentPartsRequest,
                com.clarifai.grpc.api.SingleUploadResponse>(
                  this, METHODID_PUT_UPLOAD_CONTENT_PARTS)))
          .addMethod(
            getGetUploadMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetUploadRequest,
                com.clarifai.grpc.api.SingleUploadResponse>(
                  this, METHODID_GET_UPLOAD)))
          .addMethod(
            getListUploadsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListUploadsRequest,
                com.clarifai.grpc.api.MultiUploadResponse>(
                  this, METHODID_LIST_UPLOADS)))
          .addMethod(
            getDeleteUploadsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteUploadsRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_UPLOADS)))
          .addMethod(
            getPostInputsDataSourcesMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostInputsDataSourcesRequest,
                com.clarifai.grpc.api.MultiInputsAddJobResponse>(
                  this, METHODID_POST_INPUTS_DATA_SOURCES)))
          .addMethod(
            getGetInputsExtractionJobMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetInputsExtractionJobRequest,
                com.clarifai.grpc.api.SingleInputsExtractionJobResponse>(
                  this, METHODID_GET_INPUTS_EXTRACTION_JOB)))
          .addMethod(
            getListInputsExtractionJobsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListInputsExtractionJobsRequest,
                com.clarifai.grpc.api.MultiInputsExtractionJobResponse>(
                  this, METHODID_LIST_INPUTS_EXTRACTION_JOBS)))
          .addMethod(
            getCancelInputsExtractionJobsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.CancelInputsExtractionJobsRequest,
                com.clarifai.grpc.api.MultiInputsExtractionJobResponse>(
                  this, METHODID_CANCEL_INPUTS_EXTRACTION_JOBS)))
          .addMethod(
            getPostInputsUploadsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostInputsUploadsRequest,
                com.clarifai.grpc.api.MultiInputsAddJobResponse>(
                  this, METHODID_POST_INPUTS_UPLOADS)))
          .addMethod(
            getGetRunnerMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.GetRunnerRequest,
                com.clarifai.grpc.api.SingleRunnerResponse>(
                  this, METHODID_GET_RUNNER)))
          .addMethod(
            getListRunnersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListRunnersRequest,
                com.clarifai.grpc.api.MultiRunnerResponse>(
                  this, METHODID_LIST_RUNNERS)))
          .addMethod(
            getPostRunnersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostRunnersRequest,
                com.clarifai.grpc.api.MultiRunnerResponse>(
                  this, METHODID_POST_RUNNERS)))
          .addMethod(
            getDeleteRunnersMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.DeleteRunnersRequest,
                com.clarifai.grpc.api.status.BaseResponse>(
                  this, METHODID_DELETE_RUNNERS)))
          .addMethod(
            getListRunnerItemsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.ListRunnerItemsRequest,
                com.clarifai.grpc.api.MultiRunnerItemResponse>(
                  this, METHODID_LIST_RUNNER_ITEMS)))
          .addMethod(
            getPostRunnerItemOutputsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostRunnerItemOutputsRequest,
                com.clarifai.grpc.api.MultiRunnerItemOutputResponse>(
                  this, METHODID_POST_RUNNER_ITEM_OUTPUTS)))
          .addMethod(
            getProcessRunnerItemsMethod(),
            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostRunnerItemOutputsRequest,
                com.clarifai.grpc.api.MultiRunnerItemResponse>(
                  this, METHODID_PROCESS_RUNNER_ITEMS)))
          .addMethod(
            getPostModelVersionsTrainingTimeEstimateMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.clarifai.grpc.api.PostModelVersionsTrainingTimeEstimateRequest,
                com.clarifai.grpc.api.MultiTrainingTimeEstimateResponse>(
                  this, METHODID_POST_MODEL_VERSIONS_TRAINING_TIME_ESTIMATE)))
          .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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListConceptsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List models concepts.
     * 

     */
    public void listModelConcepts(com.clarifai.grpc.api.ListModelConceptsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListModelConceptsMethod(), 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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListKnowledgeGraphsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Post domain graphs.
     * 

     */
    public void postKnowledgeGraphs(com.clarifai.grpc.api.PostKnowledgeGraphsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListAnnotationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Post annotations.
     * 

     */
    public void postAnnotations(com.clarifai.grpc.api.PostAnnotationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchAnnotationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch annotations status by worker id and task id.
     * Deprecated: Use PutTaskAssignments to update task annotations.
     *   For example, you can use PutTaskAssignments with action REVIEW_APPROVE
     *   to approve task assignments and associated annotations in bulk.
     * 

     */
    public void patchAnnotationsStatus(com.clarifai.grpc.api.PatchAnnotationsStatusRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteAnnotationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch saved annotations searches by ids.
     * 

     */
    public void patchAnnotationsSearches(com.clarifai.grpc.api.PatchAnnotationsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchAnnotationsSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Execute a search over annotations
     * 

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

    /**
     * 
     * ListAnnotationWorkers lists users, models, and workflows (collectively
     * known as "workers") that have added annotations to the application.
     * 

     */
    public void listAnnotationWorkers(com.clarifai.grpc.api.ListAnnotationWorkersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListAnnotationWorkersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get input count per status.
     * 

     */
    public void getInputCount(com.clarifai.grpc.api.GetInputCountRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetInputMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get a video input manifest.
     * 

     */
    public void getInputVideoManifest(com.clarifai.grpc.api.GetVideoManifestRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetInputVideoManifestMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List all the inputs.
     * 

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

    /**
     * 
     * Add 1 or more input to an app.
     * The actual inputs processing is asynchronous.
     * 

     */
    public void postInputs(com.clarifai.grpc.api.PostInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteInputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch saved inputs searches by ids.
     * 

     */
    public void patchInputsSearches(com.clarifai.grpc.api.PatchInputsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchInputsSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Execute a search over inputs
     * 

     */
    public void postInputsSearches(com.clarifai.grpc.api.PostInputsSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostModelOutputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * TODO(zeiler): will need to
     * Single request but streaming resopnses.
     * 

     */
    public void generateModelOutputs(com.clarifai.grpc.api.PostModelOutputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
          getChannel().newCall(getGenerateModelOutputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Stream of requests and stream of responses
     * 

     */
    public io.grpc.stub.StreamObserver streamModelOutputs(
        io.grpc.stub.StreamObserver responseObserver) {
      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
          getChannel().newCall(getStreamModelOutputsMethod(), getCallOptions()), responseObserver);
    }

    /**
     * 
     * List all the datasets.
     * 

     */
    public void listDatasets(com.clarifai.grpc.api.ListDatasetsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListDatasetsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get a specific dataset.
     * 

     */
    public void getDataset(com.clarifai.grpc.api.GetDatasetRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetDatasetMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Add datasets to an app.
     * The process is atomic, i.e. either all or no datasets are added.
     * If there is an error for one dataset,
     * the process will stop, revert the transaction and return the error.
     * 

     */
    public void postDatasets(com.clarifai.grpc.api.PostDatasetsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostDatasetsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch one or more datasets.
     * The process is atomic, i.e. either all or no datasets are patched.
     * If there is an error for one dataset,
     * the process will stop, revert the transaction and return the error.
     * 

     */
    public void patchDatasets(com.clarifai.grpc.api.PatchDatasetsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchDatasetsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Delete one or more datasets in a single request.
     * 

     */
    public void deleteDatasets(com.clarifai.grpc.api.DeleteDatasetsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteDatasetsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List all the dataset inputs in a dataset.
     * 

     */
    public void listDatasetInputs(com.clarifai.grpc.api.ListDatasetInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListDatasetInputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get a specific dataset input.
     * 

     */
    public void getDatasetInput(com.clarifai.grpc.api.GetDatasetInputRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetDatasetInputMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Add dataset inputs to a dataset.
     * The process is not atomic, i.e. if there are errors with some dataset
     * inputs, others might still be added. The response reports
     *   - SUCCESS if all dataset inputs were added,
     *   - MIXED_STATUS if only some dataset inputs were added, and
     *   - FAILURE if no dataset inputs were added.
     * Each individual dataset input in the response has the status set to
     * indicate if it was successful or if there was an error.
     * 

     */
    public void postDatasetInputs(com.clarifai.grpc.api.PostDatasetInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostDatasetInputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Delete one or more dataset inputs in a single request.
     * 

     */
    public void deleteDatasetInputs(com.clarifai.grpc.api.DeleteDatasetInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteDatasetInputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List all the dataset versions.
     * 

     */
    public void listDatasetVersions(com.clarifai.grpc.api.ListDatasetVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListDatasetVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get a specific dataset version.
     * 

     */
    public void getDatasetVersion(com.clarifai.grpc.api.GetDatasetVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetDatasetVersionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void listDatasetVersionMetricsGroups(com.clarifai.grpc.api.ListDatasetVersionMetricsGroupsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListDatasetVersionMetricsGroupsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Add dataset versions to a dataset.
     * 

     */
    public void postDatasetVersions(com.clarifai.grpc.api.PostDatasetVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostDatasetVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch one or more dataset versions.
     * 

     */
    public void patchDatasetVersions(com.clarifai.grpc.api.PatchDatasetVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchDatasetVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Delete one or more dataset versions in a single request.
     * 

     */
    public void deleteDatasetVersions(com.clarifai.grpc.api.DeleteDatasetVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteDatasetVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Create export of a dataset version.
     * 

     */
    public void putDatasetVersionExports(com.clarifai.grpc.api.PutDatasetVersionExportsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPutDatasetVersionExportsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get a specific model type.
     * 

     */
    public void getModelType(com.clarifai.grpc.api.GetModelTypeRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListModelsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List the resource counts for the app.
     * 

     */
    public void getResourceCounts(com.clarifai.grpc.api.GetResourceCountsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetResourceCountsMethod(), 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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchModelsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch one or more models ids.
     * 

     */
    public void patchModelIds(com.clarifai.grpc.api.PatchModelIdsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchModelIdsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Delete a single model.
     * 

     */
    public void deleteModel(com.clarifai.grpc.api.DeleteModelRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteModelsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Update model check consents
     * 

     */
    public void patchModelCheckConsents(com.clarifai.grpc.api.PatchModelCheckConsentsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchModelCheckConsentsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Update model toolkits tags
     * 

     */
    public void patchModelToolkits(com.clarifai.grpc.api.PatchModelToolkitsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchModelLanguagesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Deprecated: Unmaintained and ideally replaced with usage of datasets
     *   The server may refuse to accept requests to this endpoint.
     * 

     */
    @java.lang.Deprecated
    public void listModelInputs(com.clarifai.grpc.api.ListModelInputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListModelVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void postWorkflowVersionsUnPublish(com.clarifai.grpc.api.PostWorkflowVersionsUnPublishRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostWorkflowVersionsUnPublishMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void postWorkflowVersionsPublish(com.clarifai.grpc.api.PostWorkflowVersionsPublishRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostWorkflowVersionsPublishMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * PostModelVersionsPublish
     * 

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

    /**
     * 
     * PostModelVersionsUnPublish
     * 

     */
    public void postModelVersionsUnPublish(com.clarifai.grpc.api.PostModelVersionsUnPublishRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostModelVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * PatchModelVersions
     * 

     */
    public void patchModelVersions(com.clarifai.grpc.api.PatchModelVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteModelVersionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * This is a streaming endpoint, the request has a field, upload_data, which can either be the config for the upload or the actual data to upload.
     * The config must be sent first before the model_bytes can be uploaded.
     * Once the config has been sent, the server will respond with a confirmation containing the model_version_id.
     * This is so that if your upload is interrupted, you can resume the upload by sending the config again with the model_version_id specified for your model_version.
     * The actual upload will be done via a multipart upload, the latest successful part_id will be sent from the server in the response to the model_bytes.
     * 

     */
    public io.grpc.stub.StreamObserver postModelVersionsUpload(
        io.grpc.stub.StreamObserver responseObserver) {
      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
          getChannel().newCall(getPostModelVersionsUploadMethod(), getCallOptions()), responseObserver);
    }

    /**
     * 
     * Export a model
     * 

     */
    public void putModelVersionExports(com.clarifai.grpc.api.PutModelVersionExportsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPutModelVersionExportsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * GetModelVersionExport
     * 

     */
    public void getModelVersionExport(com.clarifai.grpc.api.GetModelVersionExportRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetModelVersionExportMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get the evaluation metrics for a model version.
     * Deprecated: Use GetEvaluation instead
     *   The server may refuse to accept requests to this endpoint.
     * 

     */
    public void getModelVersionMetrics(com.clarifai.grpc.api.GetModelVersionMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetModelVersionMetricsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Deprecated, use PostEvaluations instead
     * Run the evaluation metrics for a model version.
     * 

     */
    public void postModelVersionMetrics(com.clarifai.grpc.api.PostModelVersionMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostModelVersionMetricsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Deprecated, use PostEvaluations instead
     * 

     */
    public void postModelVersionEvaluations(com.clarifai.grpc.api.PostModelVersionEvaluationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostModelVersionEvaluationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Deprecated, use GetEvaluation instead
     * List the evaluation metrics for a model version.
     * 

     */
    public void listModelVersionEvaluations(com.clarifai.grpc.api.ListModelVersionEvaluationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListModelVersionEvaluationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Deprecated, use GetEvaluation instead
     * Get an evaluation metrics for a model version.
     * 

     */
    public void getModelVersionEvaluation(com.clarifai.grpc.api.GetModelVersionEvaluationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetModelVersionEvaluationMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void postEvaluations(com.clarifai.grpc.api.PostEvaluationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostEvaluationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void listEvaluations(com.clarifai.grpc.api.ListEvaluationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListEvaluationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getEvaluation(com.clarifai.grpc.api.GetEvaluationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetEvaluationMethod(), 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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListModelReferencesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * GetModelVersionInputExample
     * 

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

    /**
     * 
     * ListModelVersionInputExamples
     * 

     */
    public void listModelVersionInputExamples(com.clarifai.grpc.api.ListModelVersionInputExamplesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListWorkflowsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Add a workflow to an app.
     * Note(zeiler): the order of the workflows that are returned from this endpoint
     * may be different than the order in which the user provides them. This is because
     * we reorder by a sort that optimizes for performance of the graph and its dependencies.
     * When using the workflow in any future call the order returned by this endpoint
     * will be used.
     * 

     */
    public void postWorkflows(com.clarifai.grpc.api.PostWorkflowsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchWorkflowsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch one or more workflows ids.
     * 

     */
    public void patchWorkflowIds(com.clarifai.grpc.api.PatchWorkflowIdsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchWorkflowIdsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Delete a single workflow.
     * 

     */
    public void deleteWorkflow(com.clarifai.grpc.api.DeleteWorkflowRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostWorkflowResultsSimilarityMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List workflow versions.
     * 

     */
    public void listWorkflowVersions(com.clarifai.grpc.api.ListWorkflowVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetWorkflowVersionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Delete workflow versions.
     * 

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

    /**
     * 
     * Patch workflow versions.
     * 

     */
    public void patchWorkflowVersions(com.clarifai.grpc.api.PatchWorkflowVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getMyScopesMethod(), getCallOptions()), request, responseObserver);
    }

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

    /**
     */
    public void myScopesRoot(com.clarifai.grpc.api.MyScopesRootRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchAppsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch apps ids.
     * 

     */
    public void patchAppsIds(com.clarifai.grpc.api.PatchAppsIdsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchAppsIdsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch one app.
     * 

     */
    public void patchApp(com.clarifai.grpc.api.PatchAppRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchAppMethod(), 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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostAppsSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get user information
     * 

     */
    public void getUser(com.clarifai.grpc.api.GetUserRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetUserMethod(), 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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostValidatePasswordMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get a saved legacy search.
     * 

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

    /**
     * 
     * List all saved legacy searches.
     * 

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

    /**
     * 
     * Patch saved legacy searches by ids.
     * 

     */
    public void patchSearches(com.clarifai.grpc.api.PatchSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Execute a new search and optionally save it.
     * Deprecated: Use PostInputsSearches or PostAnnotationsSearches instead.
     *  The server may refuse to accept requests to this endpoint.
     * 

     */
    @java.lang.Deprecated
    public void postSearches(com.clarifai.grpc.api.PostSearchesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostSearchesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Execute a previously saved legacy search.
     * 

     */
    public void postSearchesByID(com.clarifai.grpc.api.PostSearchesByIDRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListAnnotationSearchMetricsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * DeleteAnnotationSearchMetrics
     * 

     */
    public void deleteAnnotationSearchMetrics(com.clarifai.grpc.api.DeleteAnnotationSearchMetricsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteSearchMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List all the annotation filters.
     * 

     */
    public void listAnnotationFilters(com.clarifai.grpc.api.ListAnnotationFiltersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListAnnotationFiltersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get a specific annotation filter.
     * 

     */
    public void getAnnotationFilter(com.clarifai.grpc.api.GetAnnotationFilterRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetAnnotationFilterMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Add annotation filters.
     * 

     */
    public void postAnnotationFilters(com.clarifai.grpc.api.PostAnnotationFiltersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostAnnotationFiltersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch one or more annotation filters.
     * 

     */
    public void patchAnnotationFilters(com.clarifai.grpc.api.PatchAnnotationFiltersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchAnnotationFiltersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Delete one or more annotation filters in a single request.
     * 

     */
    public void deleteAnnotationFilters(com.clarifai.grpc.api.DeleteAnnotationFiltersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteAnnotationFiltersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List all status codes.
     * 

     */
    public void listStatusCodes(com.clarifai.grpc.api.ListStatusCodesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostCollaboratorsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch existing collaborators.
     * 

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

    /**
     * 
     * Delete existing collaborators.
     * 

     */
    public void deleteCollaborators(com.clarifai.grpc.api.DeleteCollaboratorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListCollaborationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * PostAppDuplications starts async app duplication jobs which copy resources
     * (inputs, annotations, models etc) from one application to another. It can
     * also create the destination application if it does not exist, with fields
     * (description, metadata etc) copied from the source application.
     * A duplication job can be started by any user that can read from the source
     * application (the target of this call) and can create and write to the
     * destination application. The duplication is associated with the user that
     * created it, so in order to read the status and progress of the job, that
     * user's ID has to be used in the call to GetAppDuplication, which might be
     * different to the source application owner ID in this call.
     * 

     */
    public void postAppDuplications(com.clarifai.grpc.api.PostAppDuplicationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostAppDuplicationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * ListAppDuplications lists all app duplication jobs created by the user.
     * 

     */
    public void listAppDuplications(com.clarifai.grpc.api.ListAppDuplicationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListAppDuplicationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * GetAppDuplication returns an app duplication job created by the user.
     * 

     */
    public void getAppDuplication(com.clarifai.grpc.api.GetAppDuplicationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostTasksMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Task annotation count
     * 

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

    /**
     * 
     * Task Input count
     * 

     */
    public void getTaskInputCount(com.clarifai.grpc.api.GetTaskCountRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteTasksMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Add Label orders.
     * 

     */
    public void postLabelOrders(com.clarifai.grpc.api.PostLabelOrdersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostLabelOrdersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get a label order.
     * 

     */
    public void getLabelOrder(com.clarifai.grpc.api.GetLabelOrderRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetLabelOrderMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List label orders.
     * 

     */
    public void listLabelOrders(com.clarifai.grpc.api.ListLabelOrdersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListLabelOrdersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch one or more label orders.
     * 

     */
    public void patchLabelOrders(com.clarifai.grpc.api.PatchLabelOrdersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchLabelOrdersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Delete multiple label orders in one request.
     * this do not change task status
     * 

     */
    public void deleteLabelOrders(com.clarifai.grpc.api.DeleteLabelOrdersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteLabelOrdersMethod(), 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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteCollectorsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * PostStatValues
     * 

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

    /**
     * 
     * PostStatValuesAggregate
     * 

     */
    public void postStatValuesAggregate(com.clarifai.grpc.api.PostStatValuesAggregateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.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) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListTrendingMetricsViewsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get a specific module from an app.
     * 

     */
    public void getModule(com.clarifai.grpc.api.GetModuleRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetModuleMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List all the modules in community, by user or by app.
     * 

     */
    public void listModules(com.clarifai.grpc.api.ListModulesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListModulesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Add a modules to an app.
     * 

     */
    public void postModules(com.clarifai.grpc.api.PostModulesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostModulesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Patch one or more modules.
     * 

     */
    public void patchModules(com.clarifai.grpc.api.PatchModulesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchModulesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Delete multiple modules in one request.
     * 

     */
    public void deleteModules(com.clarifai.grpc.api.DeleteModulesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteModulesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get a specific module version for a module.
     * 

     */
    public void getModuleVersion(com.clarifai.grpc.api.GetModuleVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetModuleVersionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List all the modules versions for a given module.
     * 

     */
    public void listModuleVersions(com.clarifai.grpc.api.ListModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListModuleVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Create a new module version to trigger training of the module.
     * 

     */
    public void postModuleVersions(com.clarifai.grpc.api.PostModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostModuleVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Modify details of an existing module version.
     * 

     */
    public void patchModuleVersions(com.clarifai.grpc.api.PatchModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPatchModuleVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Delete a multiple module version.
     * 

     */
    public void deleteModuleVersions(com.clarifai.grpc.api.DeleteModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteModuleVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get usage count for specific module version.
     * 

     */
    public void getModuleVersionUsageCount(com.clarifai.grpc.api.GetModuleVersionUsageCountRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetModuleVersionUsageCountMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get installed modules vesrions for an app.
     * 

     */
    public void getInstalledModuleVersion(com.clarifai.grpc.api.GetInstalledModuleVersionRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetInstalledModuleVersionMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List installed modules vesrions for an app.
     * 

     */
    public void listInstalledModuleVersions(com.clarifai.grpc.api.ListInstalledModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListInstalledModuleVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Install a new module version which will deploy the specific ModuleVersion to the app in the url.
     * 

     */
    public void postInstalledModuleVersions(com.clarifai.grpc.api.PostInstalledModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostInstalledModuleVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Uninstall an installed module version which will deploy the specific ModuleVersion to the app
     * in the url.
     * This cleaned up any associated caller keys so needs the Keys_Delete scope.
     * 

     */
    public void deleteInstalledModuleVersions(com.clarifai.grpc.api.DeleteInstalledModuleVersionsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteInstalledModuleVersionsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Assign a key that the caller owns to be used when accessing this installed module version
     * If this endpoint is called with a different key then it overwrites what is there.
     * 

     */
    public void postInstalledModuleVersionsKey(com.clarifai.grpc.api.PostInstalledModuleVersionsKeyRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostInstalledModuleVersionsKeyMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Perform bulk operations on a list of inputs based on input source.
     * Operation include add, update, delete of concepts, metadata and geo data.
     * This is an Asynchronous process. Use ListBulkOperations or GetBulkOperation to check the status.
     * 

     */
    public void postBulkOperations(com.clarifai.grpc.api.PostBulkOperationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostBulkOperationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List all the bulk operations
     * 

     */
    public void listBulkOperations(com.clarifai.grpc.api.ListBulkOperationsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListBulkOperationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get the bulk operation details by ID
     * 

     */
    public void getBulkOperation(com.clarifai.grpc.api.GetBulkOperationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetBulkOperationMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Cancel one or more bulk operations
     * 

     */
    public void cancelBulkOperations(com.clarifai.grpc.api.CancelBulkOperationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCancelBulkOperationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * delete one or more terminated bulk operations
     * 

     */
    public void deleteBulkOperations(com.clarifai.grpc.api.DeleteBulkOperationRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteBulkOperationsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Deprecated: Use PutTaskAssignments with action=LABEL_START.
     *   This endpoint has initially been designed as a GET request,
     *   but has been re-designed to serve a PUT logic.
     *   In order to clearly highlight that this endpoint serves a PUT request,
     *   this endpoint has been deprecated and replaced by PutTaskAssignments with action=LABEL_START.
     * 

     */
    public void listNextTaskAssignments(com.clarifai.grpc.api.ListNextTaskAssignmentsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListNextTaskAssignmentsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * PutTaskAssignments performs an action for the task assignments in given task.
     * All the actions are theoretically idempotent, but practically, in the current implementation,
     * the REVIEW_START action is not idempotent. See PutTaskAssignmentsRequestAction for more details.
     * 

     */
    public void putTaskAssignments(com.clarifai.grpc.api.PutTaskAssignmentsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPutTaskAssignmentsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List all the inputs add jobs
     * 

     */
    public void listInputsAddJobs(com.clarifai.grpc.api.ListInputsAddJobsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListInputsAddJobsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get the input add job details by ID
     * 

     */
    public void getInputsAddJob(com.clarifai.grpc.api.GetInputsAddJobRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetInputsAddJobMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * cancel the input add job by ID
     * 

     */
    public void cancelInputsAddJob(com.clarifai.grpc.api.CancelInputsAddJobRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCancelInputsAddJobMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void postUploads(com.clarifai.grpc.api.PostUploadsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostUploadsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Upload a part of a multipart upload.
     * Behaviour on completion depends on the endpoint that was used to initiate the upload.
     * 

     */
    public void putUploadContentParts(com.clarifai.grpc.api.PutUploadContentPartsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPutUploadContentPartsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getUpload(com.clarifai.grpc.api.GetUploadRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetUploadMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void listUploads(com.clarifai.grpc.api.ListUploadsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListUploadsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void deleteUploads(com.clarifai.grpc.api.DeleteUploadsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteUploadsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Initiates retrieval of inputs from cloud storage from a user provided data source.
     * Will create and return an inputs-add-job for tracking progress.
     * Archives will be extracted and their contents will be processed as inputs.
     * The cloud URL will be treated as a filter prefix. For example s3:/bucket/images_folder/abc will process
     * files in the images_folder beginning with abc or in a subfolder beginning with abc.
     * For example:
     * bucket/images_folder/abcImage.png
     * bucket/images_folder/abc-1/Data.zip
     * If given URL is for a private bucket or file, then credentials should be provided to access the bucket.
     * Credentials should include rights to list the objects in the bucket, except when pointed directly at a file archive,
     * in which case it only requires rights to access that particular file.
     * 

     */
    public void postInputsDataSources(com.clarifai.grpc.api.PostInputsDataSourcesRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostInputsDataSourcesMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get the input extraction job details by ID
     * 

     */
    public void getInputsExtractionJob(com.clarifai.grpc.api.GetInputsExtractionJobRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetInputsExtractionJobMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List all the input extraction jobs
     * 

     */
    public void listInputsExtractionJobs(com.clarifai.grpc.api.ListInputsExtractionJobsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListInputsExtractionJobsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void cancelInputsExtractionJobs(com.clarifai.grpc.api.CancelInputsExtractionJobsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCancelInputsExtractionJobsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Start uploading a file archive containing inputs.
     * Will create and return an inputs-add-job for tracking progress.
     * Associated inputs-add-job contains an upload id which should be completed through `PutUploadContentParts` endpoint.
     * Completing the upload will automatically begin unpacking the archive and uploading the contents as inputs.
     * 

     */
    public void postInputsUploads(com.clarifai.grpc.api.PostInputsUploadsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostInputsUploadsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Get a specific runner.
     * TODO(zeiler): runner_id is a UUID so can list globally as well.
     * 

     */
    public void getRunner(com.clarifai.grpc.api.GetRunnerRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetRunnerMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List all the runners for the user.
     * 

     */
    public void listRunners(com.clarifai.grpc.api.ListRunnersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListRunnersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Add a runners to a user.
     * 

     */
    public void postRunners(com.clarifai.grpc.api.PostRunnersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostRunnersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Delete multiple runners in one request.
     * 

     */
    public void deleteRunners(com.clarifai.grpc.api.DeleteRunnersRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteRunnersMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * List items for the remote runner to work on.
     * since the runner_id is a UUID we can access it directly too.
     * 

     */
    public void listRunnerItems(com.clarifai.grpc.api.ListRunnerItemsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListRunnerItemsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * Post back outputs from remote runners
     * since the runner_id is a UUID we can access it directly too.
     * 

     */
    public void postRunnerItemOutputs(com.clarifai.grpc.api.PostRunnerItemOutputsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostRunnerItemOutputsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * 
     * This maintains a single request for asking the API if there is any work to be done, processing
     * it and streaming back results.
     * To do that first handshake the MultiRunnerItemOutputResponse will have RUNNER_STREAM_START
     * status filled in so that the API knows to respond with a MultiRunnerItemResponse.
     * For now there will only be one of those if the model prediction only has one request.
     * NOTE(zeiler): downside of this is you can't use HTTP REST requests to do runner work.
     * 

     */
    public io.grpc.stub.StreamObserver processRunnerItems(
        io.grpc.stub.StreamObserver responseObserver) {
      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
          getChannel().newCall(getProcessRunnerItemsMethod(), getCallOptions()), responseObserver);
    }

    /**
     * 
     * Get the training time estimate based off train request and estimated input count.
     * 

     */
    public void postModelVersionsTrainingTimeEstimate(com.clarifai.grpc.api.PostModelVersionsTrainingTimeEstimateRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getPostModelVersionsTrainingTimeEstimateMethod(), 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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetConceptMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the concepts.
     * 

     */
    public com.clarifai.grpc.api.MultiConceptResponse listConcepts(com.clarifai.grpc.api.ListConceptsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListConceptsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List models concepts.
     * 

     */
    public com.clarifai.grpc.api.MultiConceptResponse listModelConcepts(com.clarifai.grpc.api.ListModelConceptsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListModelConceptsMethod(), 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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostConceptsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more concepts.
     * 

     */
    public com.clarifai.grpc.api.MultiConceptResponse patchConcepts(com.clarifai.grpc.api.PatchConceptsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchConceptLanguagesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all domain graphs.
     * 

     */
    public com.clarifai.grpc.api.MultiKnowledgeGraphResponse listKnowledgeGraphs(com.clarifai.grpc.api.ListKnowledgeGraphsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListKnowledgeGraphsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Post domain graphs.
     * 

     */
    public com.clarifai.grpc.api.MultiKnowledgeGraphResponse postKnowledgeGraphs(com.clarifai.grpc.api.PostKnowledgeGraphsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostKnowledgeGraphsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Start concept mapping jobs.
     * 

     */
    public com.clarifai.grpc.api.MultiConceptMappingJobResponse postConceptMappingJobs(com.clarifai.grpc.api.PostConceptMappingJobsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetAnnotationMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the annotation.
     * 

     */
    public com.clarifai.grpc.api.MultiAnnotationResponse listAnnotations(com.clarifai.grpc.api.ListAnnotationsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListAnnotationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Post annotations.
     * 

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

    /**
     * 
     * Patch one or more annotations.
     * 

     */
    public com.clarifai.grpc.api.MultiAnnotationResponse patchAnnotations(com.clarifai.grpc.api.PatchAnnotationsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchAnnotationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch annotations status by worker id and task id.
     * Deprecated: Use PutTaskAssignments to update task annotations.
     *   For example, you can use PutTaskAssignments with action REVIEW_APPROVE
     *   to approve task assignments and associated annotations in bulk.
     * 

     */
    public com.clarifai.grpc.api.PatchAnnotationsStatusResponse patchAnnotationsStatus(com.clarifai.grpc.api.PatchAnnotationsStatusRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchAnnotationsStatusMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete a single annotation.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteAnnotation(com.clarifai.grpc.api.DeleteAnnotationRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteAnnotationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch saved annotations searches by ids.
     * 

     */
    public com.clarifai.grpc.api.MultiSearchResponse patchAnnotationsSearches(com.clarifai.grpc.api.PatchAnnotationsSearchesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchAnnotationsSearchesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Execute a search over annotations
     * 

     */
    public com.clarifai.grpc.api.MultiSearchResponse postAnnotationsSearches(com.clarifai.grpc.api.PostAnnotationsSearchesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostAnnotationsSearchesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * ListAnnotationWorkers lists users, models, and workflows (collectively
     * known as "workers") that have added annotations to the application.
     * 

     */
    public com.clarifai.grpc.api.MultiWorkerResponse listAnnotationWorkers(com.clarifai.grpc.api.ListAnnotationWorkersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListAnnotationWorkersMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get input count per status.
     * 

     */
    public com.clarifai.grpc.api.SingleInputCountResponse getInputCount(com.clarifai.grpc.api.GetInputCountRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetInputMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get a video input manifest.
     * 

     */
    public com.clarifai.grpc.api.GetVideoManifestResponse getInputVideoManifest(com.clarifai.grpc.api.GetVideoManifestRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetInputVideoManifestMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the inputs.
     * 

     */
    public com.clarifai.grpc.api.MultiInputResponse listInputs(com.clarifai.grpc.api.ListInputsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListInputsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Add 1 or more input to an app.
     * The actual inputs processing is asynchronous.
     * 

     */
    public com.clarifai.grpc.api.MultiInputResponse postInputs(com.clarifai.grpc.api.PostInputsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostInputsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more inputs.
     * 

     */
    public com.clarifai.grpc.api.MultiInputResponse patchInputs(com.clarifai.grpc.api.PatchInputsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteInputsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch saved inputs searches by ids.
     * 

     */
    public com.clarifai.grpc.api.MultiSearchResponse patchInputsSearches(com.clarifai.grpc.api.PatchInputsSearchesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchInputsSearchesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Execute a search over inputs
     * 

     */
    public com.clarifai.grpc.api.MultiSearchResponse postInputsSearches(com.clarifai.grpc.api.PostInputsSearchesRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostModelOutputsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * TODO(zeiler): will need to
     * Single request but streaming resopnses.
     * 

     */
    public java.util.Iterator generateModelOutputs(
        com.clarifai.grpc.api.PostModelOutputsRequest request) {
      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
          getChannel(), getGenerateModelOutputsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the datasets.
     * 

     */
    public com.clarifai.grpc.api.MultiDatasetResponse listDatasets(com.clarifai.grpc.api.ListDatasetsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListDatasetsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get a specific dataset.
     * 

     */
    public com.clarifai.grpc.api.SingleDatasetResponse getDataset(com.clarifai.grpc.api.GetDatasetRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetDatasetMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Add datasets to an app.
     * The process is atomic, i.e. either all or no datasets are added.
     * If there is an error for one dataset,
     * the process will stop, revert the transaction and return the error.
     * 

     */
    public com.clarifai.grpc.api.MultiDatasetResponse postDatasets(com.clarifai.grpc.api.PostDatasetsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostDatasetsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more datasets.
     * The process is atomic, i.e. either all or no datasets are patched.
     * If there is an error for one dataset,
     * the process will stop, revert the transaction and return the error.
     * 

     */
    public com.clarifai.grpc.api.MultiDatasetResponse patchDatasets(com.clarifai.grpc.api.PatchDatasetsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchDatasetsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete one or more datasets in a single request.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteDatasets(com.clarifai.grpc.api.DeleteDatasetsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteDatasetsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the dataset inputs in a dataset.
     * 

     */
    public com.clarifai.grpc.api.MultiDatasetInputResponse listDatasetInputs(com.clarifai.grpc.api.ListDatasetInputsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListDatasetInputsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get a specific dataset input.
     * 

     */
    public com.clarifai.grpc.api.SingleDatasetInputResponse getDatasetInput(com.clarifai.grpc.api.GetDatasetInputRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetDatasetInputMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Add dataset inputs to a dataset.
     * The process is not atomic, i.e. if there are errors with some dataset
     * inputs, others might still be added. The response reports
     *   - SUCCESS if all dataset inputs were added,
     *   - MIXED_STATUS if only some dataset inputs were added, and
     *   - FAILURE if no dataset inputs were added.
     * Each individual dataset input in the response has the status set to
     * indicate if it was successful or if there was an error.
     * 

     */
    public com.clarifai.grpc.api.MultiDatasetInputResponse postDatasetInputs(com.clarifai.grpc.api.PostDatasetInputsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostDatasetInputsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete one or more dataset inputs in a single request.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteDatasetInputs(com.clarifai.grpc.api.DeleteDatasetInputsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteDatasetInputsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the dataset versions.
     * 

     */
    public com.clarifai.grpc.api.MultiDatasetVersionResponse listDatasetVersions(com.clarifai.grpc.api.ListDatasetVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListDatasetVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get a specific dataset version.
     * 

     */
    public com.clarifai.grpc.api.SingleDatasetVersionResponse getDatasetVersion(com.clarifai.grpc.api.GetDatasetVersionRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetDatasetVersionMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.MultiDatasetVersionMetricsGroupResponse listDatasetVersionMetricsGroups(com.clarifai.grpc.api.ListDatasetVersionMetricsGroupsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListDatasetVersionMetricsGroupsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Add dataset versions to a dataset.
     * 

     */
    public com.clarifai.grpc.api.MultiDatasetVersionResponse postDatasetVersions(com.clarifai.grpc.api.PostDatasetVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostDatasetVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more dataset versions.
     * 

     */
    public com.clarifai.grpc.api.MultiDatasetVersionResponse patchDatasetVersions(com.clarifai.grpc.api.PatchDatasetVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchDatasetVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete one or more dataset versions in a single request.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteDatasetVersions(com.clarifai.grpc.api.DeleteDatasetVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteDatasetVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Create export of a dataset version.
     * 

     */
    public com.clarifai.grpc.api.MultiDatasetVersionExportResponse putDatasetVersionExports(com.clarifai.grpc.api.PutDatasetVersionExportsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPutDatasetVersionExportsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get a specific model type.
     * 

     */
    public com.clarifai.grpc.api.SingleModelTypeResponse getModelType(com.clarifai.grpc.api.GetModelTypeRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetModelOutputInfoMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the models.
     * 

     */
    public com.clarifai.grpc.api.MultiModelResponse listModels(com.clarifai.grpc.api.ListModelsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListModelsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List the resource counts for the app.
     * 

     */
    public com.clarifai.grpc.api.GetResourceCountsResponse getResourceCounts(com.clarifai.grpc.api.GetResourceCountsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetResourceCountsMethod(), 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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostModelsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more models.
     * 

     */
    public com.clarifai.grpc.api.MultiModelResponse patchModels(com.clarifai.grpc.api.PatchModelsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchModelsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more models ids.
     * 

     */
    public com.clarifai.grpc.api.MultiModelResponse patchModelIds(com.clarifai.grpc.api.PatchModelIdsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchModelIdsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete a single model.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteModel(com.clarifai.grpc.api.DeleteModelRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteModelsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Update model check consents
     * 

     */
    public com.clarifai.grpc.api.MultiModelCheckConsentResponse patchModelCheckConsents(com.clarifai.grpc.api.PatchModelCheckConsentsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchModelCheckConsentsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Update model toolkits tags
     * 

     */
    public com.clarifai.grpc.api.MultiModelToolkitResponse patchModelToolkits(com.clarifai.grpc.api.PatchModelToolkitsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchModelToolkitsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Update model use_cases tags
     * 

     */
    public com.clarifai.grpc.api.MultiModelUseCaseResponse patchModelUseCases(com.clarifai.grpc.api.PatchModelUseCasesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchModelUseCasesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Update model languages tags
     * 

     */
    public com.clarifai.grpc.api.MultiModelLanguageResponse patchModelLanguages(com.clarifai.grpc.api.PatchModelLanguagesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchModelLanguagesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Deprecated: Unmaintained and ideally replaced with usage of datasets
     *   The server may refuse to accept requests to this endpoint.
     * 

     */
    @java.lang.Deprecated
    public com.clarifai.grpc.api.MultiInputResponse listModelInputs(com.clarifai.grpc.api.ListModelInputsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetModelVersionMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the models.
     * 

     */
    public com.clarifai.grpc.api.MultiModelVersionResponse listModelVersions(com.clarifai.grpc.api.ListModelVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListModelVersionsMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.status.BaseResponse postWorkflowVersionsUnPublish(com.clarifai.grpc.api.PostWorkflowVersionsUnPublishRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostWorkflowVersionsUnPublishMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.status.BaseResponse postWorkflowVersionsPublish(com.clarifai.grpc.api.PostWorkflowVersionsPublishRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostWorkflowVersionsPublishMethod(), getCallOptions(), request);
    }

    /**
     * 
     * PostModelVersionsPublish
     * 

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

    /**
     * 
     * PostModelVersionsUnPublish
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse postModelVersionsUnPublish(com.clarifai.grpc.api.PostModelVersionsUnPublishRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostModelVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * PatchModelVersions
     * 

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

    /**
     * 
     * Delete a single model.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteModelVersion(com.clarifai.grpc.api.DeleteModelVersionRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteModelVersionMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Export a model
     * 

     */
    public com.clarifai.grpc.api.SingleModelVersionExportResponse putModelVersionExports(com.clarifai.grpc.api.PutModelVersionExportsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPutModelVersionExportsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * GetModelVersionExport
     * 

     */
    public com.clarifai.grpc.api.SingleModelVersionExportResponse getModelVersionExport(com.clarifai.grpc.api.GetModelVersionExportRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetModelVersionExportMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get the evaluation metrics for a model version.
     * Deprecated: Use GetEvaluation instead
     *   The server may refuse to accept requests to this endpoint.
     * 

     */
    public com.clarifai.grpc.api.SingleModelVersionResponse getModelVersionMetrics(com.clarifai.grpc.api.GetModelVersionMetricsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetModelVersionMetricsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Deprecated, use PostEvaluations instead
     * Run the evaluation metrics for a model version.
     * 

     */
    public com.clarifai.grpc.api.SingleModelVersionResponse postModelVersionMetrics(com.clarifai.grpc.api.PostModelVersionMetricsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostModelVersionMetricsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Deprecated, use PostEvaluations instead
     * 

     */
    public com.clarifai.grpc.api.MultiEvalMetricsResponse postModelVersionEvaluations(com.clarifai.grpc.api.PostModelVersionEvaluationsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostModelVersionEvaluationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Deprecated, use GetEvaluation instead
     * List the evaluation metrics for a model version.
     * 

     */
    public com.clarifai.grpc.api.MultiEvalMetricsResponse listModelVersionEvaluations(com.clarifai.grpc.api.ListModelVersionEvaluationsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListModelVersionEvaluationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Deprecated, use GetEvaluation instead
     * Get an evaluation metrics for a model version.
     * 

     */
    public com.clarifai.grpc.api.SingleEvalMetricsResponse getModelVersionEvaluation(com.clarifai.grpc.api.GetModelVersionEvaluationRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetModelVersionEvaluationMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.MultiEvalMetricsResponse postEvaluations(com.clarifai.grpc.api.PostEvaluationsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostEvaluationsMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.MultiEvalMetricsResponse listEvaluations(com.clarifai.grpc.api.ListEvaluationsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListEvaluationsMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.SingleEvalMetricsResponse getEvaluation(com.clarifai.grpc.api.GetEvaluationRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetEvaluationMethod(), 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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListModelReferencesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * GetModelVersionInputExample
     * 

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

    /**
     * 
     * ListModelVersionInputExamples
     * 

     */
    public com.clarifai.grpc.api.MultiModelVersionInputExampleResponse listModelVersionInputExamples(com.clarifai.grpc.api.ListModelVersionInputExamplesRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetWorkflowMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the workflows.
     * 

     */
    public com.clarifai.grpc.api.MultiWorkflowResponse listWorkflows(com.clarifai.grpc.api.ListWorkflowsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListWorkflowsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Add a workflow to an app.
     * Note(zeiler): the order of the workflows that are returned from this endpoint
     * may be different than the order in which the user provides them. This is because
     * we reorder by a sort that optimizes for performance of the graph and its dependencies.
     * When using the workflow in any future call the order returned by this endpoint
     * will be used.
     * 

     */
    public com.clarifai.grpc.api.MultiWorkflowResponse postWorkflows(com.clarifai.grpc.api.PostWorkflowsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostWorkflowsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more workflows.
     * 

     */
    public com.clarifai.grpc.api.MultiWorkflowResponse patchWorkflows(com.clarifai.grpc.api.PatchWorkflowsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchWorkflowsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more workflows ids.
     * 

     */
    public com.clarifai.grpc.api.MultiWorkflowResponse patchWorkflowIds(com.clarifai.grpc.api.PatchWorkflowIdsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchWorkflowIdsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete a single workflow.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteWorkflow(com.clarifai.grpc.api.DeleteWorkflowRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteWorkflowsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Predict using a workflow.
     * 

     */
    public com.clarifai.grpc.api.PostWorkflowResultsResponse postWorkflowResults(com.clarifai.grpc.api.PostWorkflowResultsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostWorkflowResultsSimilarityMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List workflow versions.
     * 

     */
    public com.clarifai.grpc.api.MultiWorkflowVersionResponse listWorkflowVersions(com.clarifai.grpc.api.ListWorkflowVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListWorkflowVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get single workflow version.
     * 

     */
    public com.clarifai.grpc.api.SingleWorkflowVersionResponse getWorkflowVersion(com.clarifai.grpc.api.GetWorkflowVersionRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetWorkflowVersionMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete workflow versions.
     * 

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

    /**
     * 
     * Patch workflow versions.
     * 

     */
    public com.clarifai.grpc.api.MultiWorkflowVersionResponse patchWorkflowVersions(com.clarifai.grpc.api.PatchWorkflowVersionsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetKeyMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the keys.
     * 

     */
    public com.clarifai.grpc.api.MultiKeyResponse listKeys(com.clarifai.grpc.api.ListKeysRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListKeysMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List keys by app_id
     * 

     */
    public com.clarifai.grpc.api.MultiKeyResponse listAppKeys(com.clarifai.grpc.api.ListAppKeysRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostKeysMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more keys.
     * 

     */
    public com.clarifai.grpc.api.MultiKeyResponse patchKeys(com.clarifai.grpc.api.PatchKeysRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getMyScopesMethod(), getCallOptions(), request);
    }

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

    /**
     */
    public com.clarifai.grpc.api.MultiScopeRootResponse myScopesRoot(com.clarifai.grpc.api.MyScopesRootRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetAppMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the apps.
     * 

     */
    public com.clarifai.grpc.api.MultiAppResponse listApps(com.clarifai.grpc.api.ListAppsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostAppsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more apps.
     * 

     */
    public com.clarifai.grpc.api.MultiAppResponse patchApps(com.clarifai.grpc.api.PatchAppsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchAppsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch apps ids.
     * 

     */
    public com.clarifai.grpc.api.MultiAppResponse patchAppsIds(com.clarifai.grpc.api.PatchAppsIdsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchAppsIdsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one app.
     * 

     */
    public com.clarifai.grpc.api.SingleAppResponse patchApp(com.clarifai.grpc.api.PatchAppRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchAppMethod(), 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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostAppsSearchesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get user information
     * 

     */
    public com.clarifai.grpc.api.SingleUserResponse getUser(com.clarifai.grpc.api.GetUserRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetUserMethod(), 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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostValidatePasswordMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get a saved legacy search.
     * 

     */
    public com.clarifai.grpc.api.SingleSearchResponse getSearch(com.clarifai.grpc.api.GetSearchRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetSearchMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all saved legacy searches.
     * 

     */
    public com.clarifai.grpc.api.MultiSearchResponse listSearches(com.clarifai.grpc.api.ListSearchesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListSearchesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch saved legacy searches by ids.
     * 

     */
    public com.clarifai.grpc.api.MultiSearchResponse patchSearches(com.clarifai.grpc.api.PatchSearchesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchSearchesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Execute a new search and optionally save it.
     * Deprecated: Use PostInputsSearches or PostAnnotationsSearches instead.
     *  The server may refuse to accept requests to this endpoint.
     * 

     */
    @java.lang.Deprecated
    public com.clarifai.grpc.api.MultiSearchResponse postSearches(com.clarifai.grpc.api.PostSearchesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostSearchesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Execute a previously saved legacy search.
     * 

     */
    public com.clarifai.grpc.api.MultiSearchResponse postSearchesByID(com.clarifai.grpc.api.PostSearchesByIDRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListAnnotationSearchMetricsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * DeleteAnnotationSearchMetrics
     * 

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

    /**
     * 
     * Delete a saved search.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteSearch(com.clarifai.grpc.api.DeleteSearchRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteSearchMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the annotation filters.
     * 

     */
    public com.clarifai.grpc.api.MultiAnnotationFilterResponse listAnnotationFilters(com.clarifai.grpc.api.ListAnnotationFiltersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListAnnotationFiltersMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get a specific annotation filter.
     * 

     */
    public com.clarifai.grpc.api.SingleAnnotationFilterResponse getAnnotationFilter(com.clarifai.grpc.api.GetAnnotationFilterRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetAnnotationFilterMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Add annotation filters.
     * 

     */
    public com.clarifai.grpc.api.MultiAnnotationFilterResponse postAnnotationFilters(com.clarifai.grpc.api.PostAnnotationFiltersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostAnnotationFiltersMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more annotation filters.
     * 

     */
    public com.clarifai.grpc.api.MultiAnnotationFilterResponse patchAnnotationFilters(com.clarifai.grpc.api.PatchAnnotationFiltersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchAnnotationFiltersMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete one or more annotation filters in a single request.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteAnnotationFilters(com.clarifai.grpc.api.DeleteAnnotationFiltersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteAnnotationFiltersMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all status codes.
     * 

     */
    public com.clarifai.grpc.api.MultiStatusCodeResponse listStatusCodes(com.clarifai.grpc.api.ListStatusCodesRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListCollaboratorsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * add collaborators to an app.
     * 

     */
    public com.clarifai.grpc.api.MultiCollaboratorsResponse postCollaborators(com.clarifai.grpc.api.PostCollaboratorsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostCollaboratorsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch existing collaborators.
     * 

     */
    public com.clarifai.grpc.api.MultiCollaboratorsResponse patchCollaborators(com.clarifai.grpc.api.PatchCollaboratorsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchCollaboratorsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete existing collaborators.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteCollaborators(com.clarifai.grpc.api.DeleteCollaboratorsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListCollaborationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * PostAppDuplications starts async app duplication jobs which copy resources
     * (inputs, annotations, models etc) from one application to another. It can
     * also create the destination application if it does not exist, with fields
     * (description, metadata etc) copied from the source application.
     * A duplication job can be started by any user that can read from the source
     * application (the target of this call) and can create and write to the
     * destination application. The duplication is associated with the user that
     * created it, so in order to read the status and progress of the job, that
     * user's ID has to be used in the call to GetAppDuplication, which might be
     * different to the source application owner ID in this call.
     * 

     */
    public com.clarifai.grpc.api.MultiAppDuplicationsResponse postAppDuplications(com.clarifai.grpc.api.PostAppDuplicationsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostAppDuplicationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * ListAppDuplications lists all app duplication jobs created by the user.
     * 

     */
    public com.clarifai.grpc.api.MultiAppDuplicationsResponse listAppDuplications(com.clarifai.grpc.api.ListAppDuplicationsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListAppDuplicationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * GetAppDuplication returns an app duplication job created by the user.
     * 

     */
    public com.clarifai.grpc.api.SingleAppDuplicationResponse getAppDuplication(com.clarifai.grpc.api.GetAppDuplicationRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetAppDuplicationMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Add tasks to an app.
     * 

     */
    public com.clarifai.grpc.api.MultiTaskResponse postTasks(com.clarifai.grpc.api.PostTasksRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostTasksMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Task annotation count
     * 

     */
    public com.clarifai.grpc.api.SingleTaskCountResponse getTaskAnnotationCount(com.clarifai.grpc.api.GetTaskCountRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetTaskAnnotationCountMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Task Input count
     * 

     */
    public com.clarifai.grpc.api.SingleTaskCountResponse getTaskInputCount(com.clarifai.grpc.api.GetTaskCountRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetTaskMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List tasks from an app.
     * 

     */
    public com.clarifai.grpc.api.MultiTaskResponse listTasks(com.clarifai.grpc.api.ListTasksRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListTasksMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more tasks.
     * 

     */
    public com.clarifai.grpc.api.MultiTaskResponse patchTasks(com.clarifai.grpc.api.PatchTasksRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteTasksMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Add Label orders.
     * 

     */
    public com.clarifai.grpc.api.MultiLabelOrderResponse postLabelOrders(com.clarifai.grpc.api.PostLabelOrdersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostLabelOrdersMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get a label order.
     * 

     */
    public com.clarifai.grpc.api.SingleLabelOrderResponse getLabelOrder(com.clarifai.grpc.api.GetLabelOrderRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetLabelOrderMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List label orders.
     * 

     */
    public com.clarifai.grpc.api.MultiLabelOrderResponse listLabelOrders(com.clarifai.grpc.api.ListLabelOrdersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListLabelOrdersMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more label orders.
     * 

     */
    public com.clarifai.grpc.api.MultiLabelOrderResponse patchLabelOrders(com.clarifai.grpc.api.PatchLabelOrdersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchLabelOrdersMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete multiple label orders in one request.
     * this do not change task status
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteLabelOrders(com.clarifai.grpc.api.DeleteLabelOrdersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteLabelOrdersMethod(), 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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetCollectorMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the collectors.
     * 

     */
    public com.clarifai.grpc.api.MultiCollectorResponse listCollectors(com.clarifai.grpc.api.ListCollectorsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListCollectorsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more collectors.
     * 

     */
    public com.clarifai.grpc.api.MultiCollectorResponse patchCollectors(com.clarifai.grpc.api.PatchCollectorsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteCollectorsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * PostStatValues
     * 

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

    /**
     * 
     * PostStatValuesAggregate
     * 

     */
    public com.clarifai.grpc.api.MultiStatValueAggregateResponse postStatValuesAggregate(com.clarifai.grpc.api.PostStatValuesAggregateRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListTrendingMetricsViewsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get a specific module from an app.
     * 

     */
    public com.clarifai.grpc.api.SingleModuleResponse getModule(com.clarifai.grpc.api.GetModuleRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetModuleMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the modules in community, by user or by app.
     * 

     */
    public com.clarifai.grpc.api.MultiModuleResponse listModules(com.clarifai.grpc.api.ListModulesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListModulesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Add a modules to an app.
     * 

     */
    public com.clarifai.grpc.api.MultiModuleResponse postModules(com.clarifai.grpc.api.PostModulesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostModulesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Patch one or more modules.
     * 

     */
    public com.clarifai.grpc.api.MultiModuleResponse patchModules(com.clarifai.grpc.api.PatchModulesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchModulesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete multiple modules in one request.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteModules(com.clarifai.grpc.api.DeleteModulesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteModulesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get a specific module version for a module.
     * 

     */
    public com.clarifai.grpc.api.SingleModuleVersionResponse getModuleVersion(com.clarifai.grpc.api.GetModuleVersionRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetModuleVersionMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the modules versions for a given module.
     * 

     */
    public com.clarifai.grpc.api.MultiModuleVersionResponse listModuleVersions(com.clarifai.grpc.api.ListModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListModuleVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Create a new module version to trigger training of the module.
     * 

     */
    public com.clarifai.grpc.api.MultiModuleVersionResponse postModuleVersions(com.clarifai.grpc.api.PostModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostModuleVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Modify details of an existing module version.
     * 

     */
    public com.clarifai.grpc.api.MultiModuleVersionResponse patchModuleVersions(com.clarifai.grpc.api.PatchModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPatchModuleVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete a multiple module version.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteModuleVersions(com.clarifai.grpc.api.DeleteModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteModuleVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get usage count for specific module version.
     * 

     */
    public com.clarifai.grpc.api.SingleModuleVersionUsageCountResponse getModuleVersionUsageCount(com.clarifai.grpc.api.GetModuleVersionUsageCountRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetModuleVersionUsageCountMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get installed modules vesrions for an app.
     * 

     */
    public com.clarifai.grpc.api.SingleInstalledModuleVersionResponse getInstalledModuleVersion(com.clarifai.grpc.api.GetInstalledModuleVersionRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetInstalledModuleVersionMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List installed modules vesrions for an app.
     * 

     */
    public com.clarifai.grpc.api.MultiInstalledModuleVersionResponse listInstalledModuleVersions(com.clarifai.grpc.api.ListInstalledModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListInstalledModuleVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Install a new module version which will deploy the specific ModuleVersion to the app in the url.
     * 

     */
    public com.clarifai.grpc.api.MultiInstalledModuleVersionResponse postInstalledModuleVersions(com.clarifai.grpc.api.PostInstalledModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostInstalledModuleVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Uninstall an installed module version which will deploy the specific ModuleVersion to the app
     * in the url.
     * This cleaned up any associated caller keys so needs the Keys_Delete scope.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteInstalledModuleVersions(com.clarifai.grpc.api.DeleteInstalledModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteInstalledModuleVersionsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Assign a key that the caller owns to be used when accessing this installed module version
     * If this endpoint is called with a different key then it overwrites what is there.
     * 

     */
    public com.clarifai.grpc.api.SingleKeyResponse postInstalledModuleVersionsKey(com.clarifai.grpc.api.PostInstalledModuleVersionsKeyRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostInstalledModuleVersionsKeyMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Perform bulk operations on a list of inputs based on input source.
     * Operation include add, update, delete of concepts, metadata and geo data.
     * This is an Asynchronous process. Use ListBulkOperations or GetBulkOperation to check the status.
     * 

     */
    public com.clarifai.grpc.api.MultiBulkOperationsResponse postBulkOperations(com.clarifai.grpc.api.PostBulkOperationsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostBulkOperationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the bulk operations
     * 

     */
    public com.clarifai.grpc.api.MultiBulkOperationsResponse listBulkOperations(com.clarifai.grpc.api.ListBulkOperationsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListBulkOperationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get the bulk operation details by ID
     * 

     */
    public com.clarifai.grpc.api.SingleBulkOperationsResponse getBulkOperation(com.clarifai.grpc.api.GetBulkOperationRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetBulkOperationMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Cancel one or more bulk operations
     * 

     */
    public com.clarifai.grpc.api.MultiBulkOperationsResponse cancelBulkOperations(com.clarifai.grpc.api.CancelBulkOperationRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCancelBulkOperationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * delete one or more terminated bulk operations
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteBulkOperations(com.clarifai.grpc.api.DeleteBulkOperationRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteBulkOperationsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Deprecated: Use PutTaskAssignments with action=LABEL_START.
     *   This endpoint has initially been designed as a GET request,
     *   but has been re-designed to serve a PUT logic.
     *   In order to clearly highlight that this endpoint serves a PUT request,
     *   this endpoint has been deprecated and replaced by PutTaskAssignments with action=LABEL_START.
     * 

     */
    public com.clarifai.grpc.api.MultiInputResponse listNextTaskAssignments(com.clarifai.grpc.api.ListNextTaskAssignmentsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListNextTaskAssignmentsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * PutTaskAssignments performs an action for the task assignments in given task.
     * All the actions are theoretically idempotent, but practically, in the current implementation,
     * the REVIEW_START action is not idempotent. See PutTaskAssignmentsRequestAction for more details.
     * 

     */
    public com.clarifai.grpc.api.MultiTaskAssignmentResponse putTaskAssignments(com.clarifai.grpc.api.PutTaskAssignmentsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPutTaskAssignmentsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the inputs add jobs
     * 

     */
    public com.clarifai.grpc.api.MultiInputsAddJobResponse listInputsAddJobs(com.clarifai.grpc.api.ListInputsAddJobsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListInputsAddJobsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get the input add job details by ID
     * 

     */
    public com.clarifai.grpc.api.SingleInputsAddJobResponse getInputsAddJob(com.clarifai.grpc.api.GetInputsAddJobRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetInputsAddJobMethod(), getCallOptions(), request);
    }

    /**
     * 
     * cancel the input add job by ID
     * 

     */
    public com.clarifai.grpc.api.SingleInputsAddJobResponse cancelInputsAddJob(com.clarifai.grpc.api.CancelInputsAddJobRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCancelInputsAddJobMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.MultiUploadResponse postUploads(com.clarifai.grpc.api.PostUploadsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostUploadsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Upload a part of a multipart upload.
     * Behaviour on completion depends on the endpoint that was used to initiate the upload.
     * 

     */
    public com.clarifai.grpc.api.SingleUploadResponse putUploadContentParts(com.clarifai.grpc.api.PutUploadContentPartsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPutUploadContentPartsMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.SingleUploadResponse getUpload(com.clarifai.grpc.api.GetUploadRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetUploadMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.MultiUploadResponse listUploads(com.clarifai.grpc.api.ListUploadsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListUploadsMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.status.BaseResponse deleteUploads(com.clarifai.grpc.api.DeleteUploadsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteUploadsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Initiates retrieval of inputs from cloud storage from a user provided data source.
     * Will create and return an inputs-add-job for tracking progress.
     * Archives will be extracted and their contents will be processed as inputs.
     * The cloud URL will be treated as a filter prefix. For example s3:/bucket/images_folder/abc will process
     * files in the images_folder beginning with abc or in a subfolder beginning with abc.
     * For example:
     * bucket/images_folder/abcImage.png
     * bucket/images_folder/abc-1/Data.zip
     * If given URL is for a private bucket or file, then credentials should be provided to access the bucket.
     * Credentials should include rights to list the objects in the bucket, except when pointed directly at a file archive,
     * in which case it only requires rights to access that particular file.
     * 

     */
    public com.clarifai.grpc.api.MultiInputsAddJobResponse postInputsDataSources(com.clarifai.grpc.api.PostInputsDataSourcesRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostInputsDataSourcesMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get the input extraction job details by ID
     * 

     */
    public com.clarifai.grpc.api.SingleInputsExtractionJobResponse getInputsExtractionJob(com.clarifai.grpc.api.GetInputsExtractionJobRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetInputsExtractionJobMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the input extraction jobs
     * 

     */
    public com.clarifai.grpc.api.MultiInputsExtractionJobResponse listInputsExtractionJobs(com.clarifai.grpc.api.ListInputsExtractionJobsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListInputsExtractionJobsMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.clarifai.grpc.api.MultiInputsExtractionJobResponse cancelInputsExtractionJobs(com.clarifai.grpc.api.CancelInputsExtractionJobsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCancelInputsExtractionJobsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Start uploading a file archive containing inputs.
     * Will create and return an inputs-add-job for tracking progress.
     * Associated inputs-add-job contains an upload id which should be completed through `PutUploadContentParts` endpoint.
     * Completing the upload will automatically begin unpacking the archive and uploading the contents as inputs.
     * 

     */
    public com.clarifai.grpc.api.MultiInputsAddJobResponse postInputsUploads(com.clarifai.grpc.api.PostInputsUploadsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostInputsUploadsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get a specific runner.
     * TODO(zeiler): runner_id is a UUID so can list globally as well.
     * 

     */
    public com.clarifai.grpc.api.SingleRunnerResponse getRunner(com.clarifai.grpc.api.GetRunnerRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetRunnerMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List all the runners for the user.
     * 

     */
    public com.clarifai.grpc.api.MultiRunnerResponse listRunners(com.clarifai.grpc.api.ListRunnersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListRunnersMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Add a runners to a user.
     * 

     */
    public com.clarifai.grpc.api.MultiRunnerResponse postRunners(com.clarifai.grpc.api.PostRunnersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostRunnersMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Delete multiple runners in one request.
     * 

     */
    public com.clarifai.grpc.api.status.BaseResponse deleteRunners(com.clarifai.grpc.api.DeleteRunnersRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteRunnersMethod(), getCallOptions(), request);
    }

    /**
     * 
     * List items for the remote runner to work on.
     * since the runner_id is a UUID we can access it directly too.
     * 

     */
    public com.clarifai.grpc.api.MultiRunnerItemResponse listRunnerItems(com.clarifai.grpc.api.ListRunnerItemsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListRunnerItemsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Post back outputs from remote runners
     * since the runner_id is a UUID we can access it directly too.
     * 

     */
    public com.clarifai.grpc.api.MultiRunnerItemOutputResponse postRunnerItemOutputs(com.clarifai.grpc.api.PostRunnerItemOutputsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostRunnerItemOutputsMethod(), getCallOptions(), request);
    }

    /**
     * 
     * Get the training time estimate based off train request and estimated input count.
     * 

     */
    public com.clarifai.grpc.api.MultiTrainingTimeEstimateResponse postModelVersionsTrainingTimeEstimate(com.clarifai.grpc.api.PostModelVersionsTrainingTimeEstimateRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getPostModelVersionsTrainingTimeEstimateMethod(), 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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListConceptsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List models concepts.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listModelConcepts(
        com.clarifai.grpc.api.ListModelConceptsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListModelConceptsMethod(), 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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListKnowledgeGraphsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Post domain graphs.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postKnowledgeGraphs(
        com.clarifai.grpc.api.PostKnowledgeGraphsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListAnnotationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Post annotations.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postAnnotations(
        com.clarifai.grpc.api.PostAnnotationsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchAnnotationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch annotations status by worker id and task id.
     * Deprecated: Use PutTaskAssignments to update task annotations.
     *   For example, you can use PutTaskAssignments with action REVIEW_APPROVE
     *   to approve task assignments and associated annotations in bulk.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchAnnotationsStatus(
        com.clarifai.grpc.api.PatchAnnotationsStatusRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteAnnotationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch saved annotations searches by ids.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchAnnotationsSearches(
        com.clarifai.grpc.api.PatchAnnotationsSearchesRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchAnnotationsSearchesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Execute a search over annotations
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postAnnotationsSearches(
        com.clarifai.grpc.api.PostAnnotationsSearchesRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostAnnotationsSearchesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * ListAnnotationWorkers lists users, models, and workflows (collectively
     * known as "workers") that have added annotations to the application.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listAnnotationWorkers(
        com.clarifai.grpc.api.ListAnnotationWorkersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListAnnotationWorkersMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get input count per status.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getInputCount(
        com.clarifai.grpc.api.GetInputCountRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetInputMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get a video input manifest.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getInputVideoManifest(
        com.clarifai.grpc.api.GetVideoManifestRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetInputVideoManifestMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all the inputs.
     * 

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

    /**
     * 
     * Add 1 or more input to an app.
     * The actual inputs processing is asynchronous.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postInputs(
        com.clarifai.grpc.api.PostInputsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteInputsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch saved inputs searches by ids.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchInputsSearches(
        com.clarifai.grpc.api.PatchInputsSearchesRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchInputsSearchesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Execute a search over inputs
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postInputsSearches(
        com.clarifai.grpc.api.PostInputsSearchesRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostModelOutputsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all the datasets.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listDatasets(
        com.clarifai.grpc.api.ListDatasetsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListDatasetsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get a specific dataset.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getDataset(
        com.clarifai.grpc.api.GetDatasetRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetDatasetMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Add datasets to an app.
     * The process is atomic, i.e. either all or no datasets are added.
     * If there is an error for one dataset,
     * the process will stop, revert the transaction and return the error.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postDatasets(
        com.clarifai.grpc.api.PostDatasetsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostDatasetsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch one or more datasets.
     * The process is atomic, i.e. either all or no datasets are patched.
     * If there is an error for one dataset,
     * the process will stop, revert the transaction and return the error.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchDatasets(
        com.clarifai.grpc.api.PatchDatasetsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchDatasetsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Delete one or more datasets in a single request.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteDatasets(
        com.clarifai.grpc.api.DeleteDatasetsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteDatasetsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all the dataset inputs in a dataset.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listDatasetInputs(
        com.clarifai.grpc.api.ListDatasetInputsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListDatasetInputsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get a specific dataset input.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getDatasetInput(
        com.clarifai.grpc.api.GetDatasetInputRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetDatasetInputMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Add dataset inputs to a dataset.
     * The process is not atomic, i.e. if there are errors with some dataset
     * inputs, others might still be added. The response reports
     *   - SUCCESS if all dataset inputs were added,
     *   - MIXED_STATUS if only some dataset inputs were added, and
     *   - FAILURE if no dataset inputs were added.
     * Each individual dataset input in the response has the status set to
     * indicate if it was successful or if there was an error.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postDatasetInputs(
        com.clarifai.grpc.api.PostDatasetInputsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostDatasetInputsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Delete one or more dataset inputs in a single request.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteDatasetInputs(
        com.clarifai.grpc.api.DeleteDatasetInputsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteDatasetInputsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all the dataset versions.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listDatasetVersions(
        com.clarifai.grpc.api.ListDatasetVersionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListDatasetVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get a specific dataset version.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getDatasetVersion(
        com.clarifai.grpc.api.GetDatasetVersionRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetDatasetVersionMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture listDatasetVersionMetricsGroups(
        com.clarifai.grpc.api.ListDatasetVersionMetricsGroupsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListDatasetVersionMetricsGroupsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Add dataset versions to a dataset.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postDatasetVersions(
        com.clarifai.grpc.api.PostDatasetVersionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostDatasetVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch one or more dataset versions.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchDatasetVersions(
        com.clarifai.grpc.api.PatchDatasetVersionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchDatasetVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Delete one or more dataset versions in a single request.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteDatasetVersions(
        com.clarifai.grpc.api.DeleteDatasetVersionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteDatasetVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Create export of a dataset version.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture putDatasetVersionExports(
        com.clarifai.grpc.api.PutDatasetVersionExportsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPutDatasetVersionExportsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get a specific model type.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getModelType(
        com.clarifai.grpc.api.GetModelTypeRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListModelsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List the resource counts for the app.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getResourceCounts(
        com.clarifai.grpc.api.GetResourceCountsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetResourceCountsMethod(), 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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchModelsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch one or more models ids.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchModelIds(
        com.clarifai.grpc.api.PatchModelIdsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchModelIdsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Delete a single model.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteModel(
        com.clarifai.grpc.api.DeleteModelRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteModelsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Update model check consents
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchModelCheckConsents(
        com.clarifai.grpc.api.PatchModelCheckConsentsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchModelCheckConsentsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Update model toolkits tags
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchModelToolkits(
        com.clarifai.grpc.api.PatchModelToolkitsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchModelLanguagesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Deprecated: Unmaintained and ideally replaced with usage of datasets
     *   The server may refuse to accept requests to this endpoint.
     * 

     */
    @java.lang.Deprecated
    public com.google.common.util.concurrent.ListenableFuture listModelInputs(
        com.clarifai.grpc.api.ListModelInputsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListModelVersionsMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture postWorkflowVersionsUnPublish(
        com.clarifai.grpc.api.PostWorkflowVersionsUnPublishRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostWorkflowVersionsUnPublishMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture postWorkflowVersionsPublish(
        com.clarifai.grpc.api.PostWorkflowVersionsPublishRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostWorkflowVersionsPublishMethod(), getCallOptions()), request);
    }

    /**
     * 
     * PostModelVersionsPublish
     * 

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

    /**
     * 
     * PostModelVersionsUnPublish
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postModelVersionsUnPublish(
        com.clarifai.grpc.api.PostModelVersionsUnPublishRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostModelVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * PatchModelVersions
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchModelVersions(
        com.clarifai.grpc.api.PatchModelVersionsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteModelVersionMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Export a model
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture putModelVersionExports(
        com.clarifai.grpc.api.PutModelVersionExportsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPutModelVersionExportsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * GetModelVersionExport
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getModelVersionExport(
        com.clarifai.grpc.api.GetModelVersionExportRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetModelVersionExportMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get the evaluation metrics for a model version.
     * Deprecated: Use GetEvaluation instead
     *   The server may refuse to accept requests to this endpoint.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getModelVersionMetrics(
        com.clarifai.grpc.api.GetModelVersionMetricsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetModelVersionMetricsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Deprecated, use PostEvaluations instead
     * Run the evaluation metrics for a model version.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postModelVersionMetrics(
        com.clarifai.grpc.api.PostModelVersionMetricsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostModelVersionMetricsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Deprecated, use PostEvaluations instead
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postModelVersionEvaluations(
        com.clarifai.grpc.api.PostModelVersionEvaluationsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostModelVersionEvaluationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Deprecated, use GetEvaluation instead
     * List the evaluation metrics for a model version.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listModelVersionEvaluations(
        com.clarifai.grpc.api.ListModelVersionEvaluationsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListModelVersionEvaluationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Deprecated, use GetEvaluation instead
     * Get an evaluation metrics for a model version.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getModelVersionEvaluation(
        com.clarifai.grpc.api.GetModelVersionEvaluationRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetModelVersionEvaluationMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture postEvaluations(
        com.clarifai.grpc.api.PostEvaluationsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostEvaluationsMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture listEvaluations(
        com.clarifai.grpc.api.ListEvaluationsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListEvaluationsMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture getEvaluation(
        com.clarifai.grpc.api.GetEvaluationRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetEvaluationMethod(), 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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListModelReferencesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * GetModelVersionInputExample
     * 

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

    /**
     * 
     * ListModelVersionInputExamples
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listModelVersionInputExamples(
        com.clarifai.grpc.api.ListModelVersionInputExamplesRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListWorkflowsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Add a workflow to an app.
     * Note(zeiler): the order of the workflows that are returned from this endpoint
     * may be different than the order in which the user provides them. This is because
     * we reorder by a sort that optimizes for performance of the graph and its dependencies.
     * When using the workflow in any future call the order returned by this endpoint
     * will be used.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postWorkflows(
        com.clarifai.grpc.api.PostWorkflowsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchWorkflowsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch one or more workflows ids.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchWorkflowIds(
        com.clarifai.grpc.api.PatchWorkflowIdsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchWorkflowIdsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Delete a single workflow.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteWorkflow(
        com.clarifai.grpc.api.DeleteWorkflowRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostWorkflowResultsSimilarityMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List workflow versions.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listWorkflowVersions(
        com.clarifai.grpc.api.ListWorkflowVersionsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetWorkflowVersionMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Delete workflow versions.
     * 

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

    /**
     * 
     * Patch workflow versions.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchWorkflowVersions(
        com.clarifai.grpc.api.PatchWorkflowVersionsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getMyScopesMethod(), getCallOptions()), request);
    }

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

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture myScopesRoot(
        com.clarifai.grpc.api.MyScopesRootRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchAppsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch apps ids.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchAppsIds(
        com.clarifai.grpc.api.PatchAppsIdsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchAppsIdsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch one app.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchApp(
        com.clarifai.grpc.api.PatchAppRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchAppMethod(), 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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostAppsSearchesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get user information
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getUser(
        com.clarifai.grpc.api.GetUserRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetUserMethod(), 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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostValidatePasswordMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get a saved legacy search.
     * 

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

    /**
     * 
     * List all saved legacy searches.
     * 

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

    /**
     * 
     * Patch saved legacy searches by ids.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchSearches(
        com.clarifai.grpc.api.PatchSearchesRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchSearchesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Execute a new search and optionally save it.
     * Deprecated: Use PostInputsSearches or PostAnnotationsSearches instead.
     *  The server may refuse to accept requests to this endpoint.
     * 

     */
    @java.lang.Deprecated
    public com.google.common.util.concurrent.ListenableFuture postSearches(
        com.clarifai.grpc.api.PostSearchesRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostSearchesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Execute a previously saved legacy search.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postSearchesByID(
        com.clarifai.grpc.api.PostSearchesByIDRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListAnnotationSearchMetricsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * DeleteAnnotationSearchMetrics
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteAnnotationSearchMetrics(
        com.clarifai.grpc.api.DeleteAnnotationSearchMetricsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteSearchMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all the annotation filters.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listAnnotationFilters(
        com.clarifai.grpc.api.ListAnnotationFiltersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListAnnotationFiltersMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get a specific annotation filter.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getAnnotationFilter(
        com.clarifai.grpc.api.GetAnnotationFilterRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetAnnotationFilterMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Add annotation filters.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postAnnotationFilters(
        com.clarifai.grpc.api.PostAnnotationFiltersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostAnnotationFiltersMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch one or more annotation filters.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchAnnotationFilters(
        com.clarifai.grpc.api.PatchAnnotationFiltersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchAnnotationFiltersMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Delete one or more annotation filters in a single request.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteAnnotationFilters(
        com.clarifai.grpc.api.DeleteAnnotationFiltersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteAnnotationFiltersMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all status codes.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listStatusCodes(
        com.clarifai.grpc.api.ListStatusCodesRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostCollaboratorsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch existing collaborators.
     * 

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

    /**
     * 
     * Delete existing collaborators.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteCollaborators(
        com.clarifai.grpc.api.DeleteCollaboratorsRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListCollaborationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * PostAppDuplications starts async app duplication jobs which copy resources
     * (inputs, annotations, models etc) from one application to another. It can
     * also create the destination application if it does not exist, with fields
     * (description, metadata etc) copied from the source application.
     * A duplication job can be started by any user that can read from the source
     * application (the target of this call) and can create and write to the
     * destination application. The duplication is associated with the user that
     * created it, so in order to read the status and progress of the job, that
     * user's ID has to be used in the call to GetAppDuplication, which might be
     * different to the source application owner ID in this call.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postAppDuplications(
        com.clarifai.grpc.api.PostAppDuplicationsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostAppDuplicationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * ListAppDuplications lists all app duplication jobs created by the user.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listAppDuplications(
        com.clarifai.grpc.api.ListAppDuplicationsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListAppDuplicationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * GetAppDuplication returns an app duplication job created by the user.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getAppDuplication(
        com.clarifai.grpc.api.GetAppDuplicationRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostTasksMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Task annotation count
     * 

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

    /**
     * 
     * Task Input count
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getTaskInputCount(
        com.clarifai.grpc.api.GetTaskCountRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteTasksMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Add Label orders.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postLabelOrders(
        com.clarifai.grpc.api.PostLabelOrdersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostLabelOrdersMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get a label order.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getLabelOrder(
        com.clarifai.grpc.api.GetLabelOrderRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetLabelOrderMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List label orders.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listLabelOrders(
        com.clarifai.grpc.api.ListLabelOrdersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListLabelOrdersMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch one or more label orders.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchLabelOrders(
        com.clarifai.grpc.api.PatchLabelOrdersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchLabelOrdersMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Delete multiple label orders in one request.
     * this do not change task status
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteLabelOrders(
        com.clarifai.grpc.api.DeleteLabelOrdersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteLabelOrdersMethod(), 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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteCollectorsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * PostStatValues
     * 

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

    /**
     * 
     * PostStatValuesAggregate
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postStatValuesAggregate(
        com.clarifai.grpc.api.PostStatValuesAggregateRequest request) {
      return io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.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 io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListTrendingMetricsViewsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get a specific module from an app.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getModule(
        com.clarifai.grpc.api.GetModuleRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetModuleMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all the modules in community, by user or by app.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listModules(
        com.clarifai.grpc.api.ListModulesRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListModulesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Add a modules to an app.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postModules(
        com.clarifai.grpc.api.PostModulesRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostModulesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Patch one or more modules.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchModules(
        com.clarifai.grpc.api.PatchModulesRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchModulesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Delete multiple modules in one request.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteModules(
        com.clarifai.grpc.api.DeleteModulesRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteModulesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get a specific module version for a module.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getModuleVersion(
        com.clarifai.grpc.api.GetModuleVersionRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetModuleVersionMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all the modules versions for a given module.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listModuleVersions(
        com.clarifai.grpc.api.ListModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListModuleVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Create a new module version to trigger training of the module.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postModuleVersions(
        com.clarifai.grpc.api.PostModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostModuleVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Modify details of an existing module version.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture patchModuleVersions(
        com.clarifai.grpc.api.PatchModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPatchModuleVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Delete a multiple module version.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteModuleVersions(
        com.clarifai.grpc.api.DeleteModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteModuleVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get usage count for specific module version.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getModuleVersionUsageCount(
        com.clarifai.grpc.api.GetModuleVersionUsageCountRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetModuleVersionUsageCountMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get installed modules vesrions for an app.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getInstalledModuleVersion(
        com.clarifai.grpc.api.GetInstalledModuleVersionRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetInstalledModuleVersionMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List installed modules vesrions for an app.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listInstalledModuleVersions(
        com.clarifai.grpc.api.ListInstalledModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListInstalledModuleVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Install a new module version which will deploy the specific ModuleVersion to the app in the url.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postInstalledModuleVersions(
        com.clarifai.grpc.api.PostInstalledModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostInstalledModuleVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Uninstall an installed module version which will deploy the specific ModuleVersion to the app
     * in the url.
     * This cleaned up any associated caller keys so needs the Keys_Delete scope.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteInstalledModuleVersions(
        com.clarifai.grpc.api.DeleteInstalledModuleVersionsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteInstalledModuleVersionsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Assign a key that the caller owns to be used when accessing this installed module version
     * If this endpoint is called with a different key then it overwrites what is there.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postInstalledModuleVersionsKey(
        com.clarifai.grpc.api.PostInstalledModuleVersionsKeyRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostInstalledModuleVersionsKeyMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Perform bulk operations on a list of inputs based on input source.
     * Operation include add, update, delete of concepts, metadata and geo data.
     * This is an Asynchronous process. Use ListBulkOperations or GetBulkOperation to check the status.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postBulkOperations(
        com.clarifai.grpc.api.PostBulkOperationsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostBulkOperationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all the bulk operations
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listBulkOperations(
        com.clarifai.grpc.api.ListBulkOperationsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListBulkOperationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get the bulk operation details by ID
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getBulkOperation(
        com.clarifai.grpc.api.GetBulkOperationRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetBulkOperationMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Cancel one or more bulk operations
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture cancelBulkOperations(
        com.clarifai.grpc.api.CancelBulkOperationRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCancelBulkOperationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * delete one or more terminated bulk operations
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteBulkOperations(
        com.clarifai.grpc.api.DeleteBulkOperationRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteBulkOperationsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Deprecated: Use PutTaskAssignments with action=LABEL_START.
     *   This endpoint has initially been designed as a GET request,
     *   but has been re-designed to serve a PUT logic.
     *   In order to clearly highlight that this endpoint serves a PUT request,
     *   this endpoint has been deprecated and replaced by PutTaskAssignments with action=LABEL_START.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listNextTaskAssignments(
        com.clarifai.grpc.api.ListNextTaskAssignmentsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListNextTaskAssignmentsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * PutTaskAssignments performs an action for the task assignments in given task.
     * All the actions are theoretically idempotent, but practically, in the current implementation,
     * the REVIEW_START action is not idempotent. See PutTaskAssignmentsRequestAction for more details.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture putTaskAssignments(
        com.clarifai.grpc.api.PutTaskAssignmentsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPutTaskAssignmentsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all the inputs add jobs
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listInputsAddJobs(
        com.clarifai.grpc.api.ListInputsAddJobsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListInputsAddJobsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get the input add job details by ID
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getInputsAddJob(
        com.clarifai.grpc.api.GetInputsAddJobRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetInputsAddJobMethod(), getCallOptions()), request);
    }

    /**
     * 
     * cancel the input add job by ID
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture cancelInputsAddJob(
        com.clarifai.grpc.api.CancelInputsAddJobRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCancelInputsAddJobMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture postUploads(
        com.clarifai.grpc.api.PostUploadsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostUploadsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Upload a part of a multipart upload.
     * Behaviour on completion depends on the endpoint that was used to initiate the upload.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture putUploadContentParts(
        com.clarifai.grpc.api.PutUploadContentPartsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPutUploadContentPartsMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture getUpload(
        com.clarifai.grpc.api.GetUploadRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetUploadMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture listUploads(
        com.clarifai.grpc.api.ListUploadsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListUploadsMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture deleteUploads(
        com.clarifai.grpc.api.DeleteUploadsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteUploadsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Initiates retrieval of inputs from cloud storage from a user provided data source.
     * Will create and return an inputs-add-job for tracking progress.
     * Archives will be extracted and their contents will be processed as inputs.
     * The cloud URL will be treated as a filter prefix. For example s3:/bucket/images_folder/abc will process
     * files in the images_folder beginning with abc or in a subfolder beginning with abc.
     * For example:
     * bucket/images_folder/abcImage.png
     * bucket/images_folder/abc-1/Data.zip
     * If given URL is for a private bucket or file, then credentials should be provided to access the bucket.
     * Credentials should include rights to list the objects in the bucket, except when pointed directly at a file archive,
     * in which case it only requires rights to access that particular file.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postInputsDataSources(
        com.clarifai.grpc.api.PostInputsDataSourcesRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostInputsDataSourcesMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get the input extraction job details by ID
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getInputsExtractionJob(
        com.clarifai.grpc.api.GetInputsExtractionJobRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetInputsExtractionJobMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all the input extraction jobs
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listInputsExtractionJobs(
        com.clarifai.grpc.api.ListInputsExtractionJobsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListInputsExtractionJobsMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture cancelInputsExtractionJobs(
        com.clarifai.grpc.api.CancelInputsExtractionJobsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCancelInputsExtractionJobsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Start uploading a file archive containing inputs.
     * Will create and return an inputs-add-job for tracking progress.
     * Associated inputs-add-job contains an upload id which should be completed through `PutUploadContentParts` endpoint.
     * Completing the upload will automatically begin unpacking the archive and uploading the contents as inputs.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postInputsUploads(
        com.clarifai.grpc.api.PostInputsUploadsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostInputsUploadsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get a specific runner.
     * TODO(zeiler): runner_id is a UUID so can list globally as well.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture getRunner(
        com.clarifai.grpc.api.GetRunnerRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetRunnerMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List all the runners for the user.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listRunners(
        com.clarifai.grpc.api.ListRunnersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListRunnersMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Add a runners to a user.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postRunners(
        com.clarifai.grpc.api.PostRunnersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostRunnersMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Delete multiple runners in one request.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture deleteRunners(
        com.clarifai.grpc.api.DeleteRunnersRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteRunnersMethod(), getCallOptions()), request);
    }

    /**
     * 
     * List items for the remote runner to work on.
     * since the runner_id is a UUID we can access it directly too.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture listRunnerItems(
        com.clarifai.grpc.api.ListRunnerItemsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListRunnerItemsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Post back outputs from remote runners
     * since the runner_id is a UUID we can access it directly too.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postRunnerItemOutputs(
        com.clarifai.grpc.api.PostRunnerItemOutputsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostRunnerItemOutputsMethod(), getCallOptions()), request);
    }

    /**
     * 
     * Get the training time estimate based off train request and estimated input count.
     * 

     */
    public com.google.common.util.concurrent.ListenableFuture postModelVersionsTrainingTimeEstimate(
        com.clarifai.grpc.api.PostModelVersionsTrainingTimeEstimateRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getPostModelVersionsTrainingTimeEstimateMethod(), 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_LIST_MODEL_CONCEPTS = 6;
  private static final int METHODID_POST_CONCEPTS_SEARCHES = 7;
  private static final int METHODID_POST_CONCEPTS = 8;
  private static final int METHODID_PATCH_CONCEPTS = 9;
  private static final int METHODID_GET_CONCEPT_LANGUAGE = 10;
  private static final int METHODID_LIST_CONCEPT_LANGUAGES = 11;
  private static final int METHODID_POST_CONCEPT_LANGUAGES = 12;
  private static final int METHODID_PATCH_CONCEPT_LANGUAGES = 13;
  private static final int METHODID_LIST_KNOWLEDGE_GRAPHS = 14;
  private static final int METHODID_POST_KNOWLEDGE_GRAPHS = 15;
  private static final int METHODID_POST_CONCEPT_MAPPING_JOBS = 16;
  private static final int METHODID_GET_ANNOTATION = 17;
  private static final int METHODID_LIST_ANNOTATIONS = 18;
  private static final int METHODID_POST_ANNOTATIONS = 19;
  private static final int METHODID_PATCH_ANNOTATIONS = 20;
  private static final int METHODID_PATCH_ANNOTATIONS_STATUS = 21;
  private static final int METHODID_DELETE_ANNOTATION = 22;
  private static final int METHODID_DELETE_ANNOTATIONS = 23;
  private static final int METHODID_PATCH_ANNOTATIONS_SEARCHES = 24;
  private static final int METHODID_POST_ANNOTATIONS_SEARCHES = 25;
  private static final int METHODID_LIST_ANNOTATION_WORKERS = 26;
  private static final int METHODID_GET_INPUT_COUNT = 27;
  private static final int METHODID_STREAM_INPUTS = 28;
  private static final int METHODID_GET_INPUT_SAMPLES = 29;
  private static final int METHODID_GET_INPUT = 30;
  private static final int METHODID_GET_INPUT_VIDEO_MANIFEST = 31;
  private static final int METHODID_LIST_INPUTS = 32;
  private static final int METHODID_POST_INPUTS = 33;
  private static final int METHODID_PATCH_INPUTS = 34;
  private static final int METHODID_DELETE_INPUT = 35;
  private static final int METHODID_DELETE_INPUTS = 36;
  private static final int METHODID_PATCH_INPUTS_SEARCHES = 37;
  private static final int METHODID_POST_INPUTS_SEARCHES = 38;
  private static final int METHODID_POST_MODEL_OUTPUTS = 39;
  private static final int METHODID_GENERATE_MODEL_OUTPUTS = 40;
  private static final int METHODID_LIST_DATASETS = 41;
  private static final int METHODID_GET_DATASET = 42;
  private static final int METHODID_POST_DATASETS = 43;
  private static final int METHODID_PATCH_DATASETS = 44;
  private static final int METHODID_DELETE_DATASETS = 45;
  private static final int METHODID_LIST_DATASET_INPUTS = 46;
  private static final int METHODID_GET_DATASET_INPUT = 47;
  private static final int METHODID_POST_DATASET_INPUTS = 48;
  private static final int METHODID_DELETE_DATASET_INPUTS = 49;
  private static final int METHODID_LIST_DATASET_VERSIONS = 50;
  private static final int METHODID_GET_DATASET_VERSION = 51;
  private static final int METHODID_LIST_DATASET_VERSION_METRICS_GROUPS = 52;
  private static final int METHODID_POST_DATASET_VERSIONS = 53;
  private static final int METHODID_PATCH_DATASET_VERSIONS = 54;
  private static final int METHODID_DELETE_DATASET_VERSIONS = 55;
  private static final int METHODID_PUT_DATASET_VERSION_EXPORTS = 56;
  private static final int METHODID_GET_MODEL_TYPE = 57;
  private static final int METHODID_LIST_OPEN_SOURCE_LICENSES = 58;
  private static final int METHODID_LIST_MODEL_TYPES = 59;
  private static final int METHODID_GET_MODEL = 60;
  private static final int METHODID_GET_MODEL_OUTPUT_INFO = 61;
  private static final int METHODID_LIST_MODELS = 62;
  private static final int METHODID_GET_RESOURCE_COUNTS = 63;
  private static final int METHODID_POST_MODELS_SEARCHES = 64;
  private static final int METHODID_POST_MODELS = 65;
  private static final int METHODID_PATCH_MODELS = 66;
  private static final int METHODID_PATCH_MODEL_IDS = 67;
  private static final int METHODID_DELETE_MODEL = 68;
  private static final int METHODID_DELETE_MODELS = 69;
  private static final int METHODID_PATCH_MODEL_CHECK_CONSENTS = 70;
  private static final int METHODID_PATCH_MODEL_TOOLKITS = 71;
  private static final int METHODID_PATCH_MODEL_USE_CASES = 72;
  private static final int METHODID_PATCH_MODEL_LANGUAGES = 73;
  private static final int METHODID_LIST_MODEL_INPUTS = 74;
  private static final int METHODID_GET_MODEL_VERSION = 75;
  private static final int METHODID_LIST_MODEL_VERSIONS = 76;
  private static final int METHODID_POST_WORKFLOW_VERSIONS_UN_PUBLISH = 77;
  private static final int METHODID_POST_WORKFLOW_VERSIONS_PUBLISH = 78;
  private static final int METHODID_POST_MODEL_VERSIONS_PUBLISH = 79;
  private static final int METHODID_POST_MODEL_VERSIONS_UN_PUBLISH = 80;
  private static final int METHODID_POST_MODEL_VERSIONS = 81;
  private static final int METHODID_PATCH_MODEL_VERSIONS = 82;
  private static final int METHODID_DELETE_MODEL_VERSION = 83;
  private static final int METHODID_PUT_MODEL_VERSION_EXPORTS = 84;
  private static final int METHODID_GET_MODEL_VERSION_EXPORT = 85;
  private static final int METHODID_GET_MODEL_VERSION_METRICS = 86;
  private static final int METHODID_POST_MODEL_VERSION_METRICS = 87;
  private static final int METHODID_POST_MODEL_VERSION_EVALUATIONS = 88;
  private static final int METHODID_LIST_MODEL_VERSION_EVALUATIONS = 89;
  private static final int METHODID_GET_MODEL_VERSION_EVALUATION = 90;
  private static final int METHODID_POST_EVALUATIONS = 91;
  private static final int METHODID_LIST_EVALUATIONS = 92;
  private static final int METHODID_GET_EVALUATION = 93;
  private static final int METHODID_LIST_MODEL_REFERENCES = 94;
  private static final int METHODID_GET_MODEL_VERSION_INPUT_EXAMPLE = 95;
  private static final int METHODID_LIST_MODEL_VERSION_INPUT_EXAMPLES = 96;
  private static final int METHODID_GET_WORKFLOW = 97;
  private static final int METHODID_LIST_WORKFLOWS = 98;
  private static final int METHODID_POST_WORKFLOWS = 99;
  private static final int METHODID_PATCH_WORKFLOWS = 100;
  private static final int METHODID_PATCH_WORKFLOW_IDS = 101;
  private static final int METHODID_DELETE_WORKFLOW = 102;
  private static final int METHODID_DELETE_WORKFLOWS = 103;
  private static final int METHODID_POST_WORKFLOW_RESULTS = 104;
  private static final int METHODID_POST_WORKFLOW_RESULTS_SIMILARITY = 105;
  private static final int METHODID_LIST_WORKFLOW_VERSIONS = 106;
  private static final int METHODID_GET_WORKFLOW_VERSION = 107;
  private static final int METHODID_DELETE_WORKFLOW_VERSIONS = 108;
  private static final int METHODID_PATCH_WORKFLOW_VERSIONS = 109;
  private static final int METHODID_GET_KEY = 110;
  private static final int METHODID_LIST_KEYS = 111;
  private static final int METHODID_LIST_APP_KEYS = 112;
  private static final int METHODID_DELETE_KEY = 113;
  private static final int METHODID_POST_KEYS = 114;
  private static final int METHODID_PATCH_KEYS = 115;
  private static final int METHODID_MY_SCOPES = 116;
  private static final int METHODID_MY_SCOPES_USER = 117;
  private static final int METHODID_MY_SCOPES_ROOT = 118;
  private static final int METHODID_LIST_SCOPES = 119;
  private static final int METHODID_GET_APP = 120;
  private static final int METHODID_LIST_APPS = 121;
  private static final int METHODID_DELETE_APP = 122;
  private static final int METHODID_POST_APPS = 123;
  private static final int METHODID_PATCH_APPS = 124;
  private static final int METHODID_PATCH_APPS_IDS = 125;
  private static final int METHODID_PATCH_APP = 126;
  private static final int METHODID_POST_APPS_SEARCHES = 127;
  private static final int METHODID_GET_USER = 128;
  private static final int METHODID_POST_VALIDATE_PASSWORD = 129;
  private static final int METHODID_GET_SEARCH = 130;
  private static final int METHODID_LIST_SEARCHES = 131;
  private static final int METHODID_PATCH_SEARCHES = 132;
  private static final int METHODID_POST_SEARCHES = 133;
  private static final int METHODID_POST_SEARCHES_BY_ID = 134;
  private static final int METHODID_POST_ANNOTATION_SEARCH_METRICS = 135;
  private static final int METHODID_GET_ANNOTATION_SEARCH_METRICS = 136;
  private static final int METHODID_LIST_ANNOTATION_SEARCH_METRICS = 137;
  private static final int METHODID_DELETE_ANNOTATION_SEARCH_METRICS = 138;
  private static final int METHODID_DELETE_SEARCH = 139;
  private static final int METHODID_LIST_ANNOTATION_FILTERS = 140;
  private static final int METHODID_GET_ANNOTATION_FILTER = 141;
  private static final int METHODID_POST_ANNOTATION_FILTERS = 142;
  private static final int METHODID_PATCH_ANNOTATION_FILTERS = 143;
  private static final int METHODID_DELETE_ANNOTATION_FILTERS = 144;
  private static final int METHODID_LIST_STATUS_CODES = 145;
  private static final int METHODID_GET_STATUS_CODE = 146;
  private static final int METHODID_LIST_COLLABORATORS = 147;
  private static final int METHODID_POST_COLLABORATORS = 148;
  private static final int METHODID_PATCH_COLLABORATORS = 149;
  private static final int METHODID_DELETE_COLLABORATORS = 150;
  private static final int METHODID_LIST_COLLABORATIONS = 151;
  private static final int METHODID_POST_APP_DUPLICATIONS = 152;
  private static final int METHODID_LIST_APP_DUPLICATIONS = 153;
  private static final int METHODID_GET_APP_DUPLICATION = 154;
  private static final int METHODID_POST_TASKS = 155;
  private static final int METHODID_GET_TASK_ANNOTATION_COUNT = 156;
  private static final int METHODID_GET_TASK_INPUT_COUNT = 157;
  private static final int METHODID_GET_TASK = 158;
  private static final int METHODID_LIST_TASKS = 159;
  private static final int METHODID_PATCH_TASKS = 160;
  private static final int METHODID_DELETE_TASKS = 161;
  private static final int METHODID_POST_LABEL_ORDERS = 162;
  private static final int METHODID_GET_LABEL_ORDER = 163;
  private static final int METHODID_LIST_LABEL_ORDERS = 164;
  private static final int METHODID_PATCH_LABEL_ORDERS = 165;
  private static final int METHODID_DELETE_LABEL_ORDERS = 166;
  private static final int METHODID_POST_COLLECTORS = 167;
  private static final int METHODID_GET_COLLECTOR = 168;
  private static final int METHODID_LIST_COLLECTORS = 169;
  private static final int METHODID_PATCH_COLLECTORS = 170;
  private static final int METHODID_DELETE_COLLECTORS = 171;
  private static final int METHODID_POST_STAT_VALUES = 172;
  private static final int METHODID_POST_STAT_VALUES_AGGREGATE = 173;
  private static final int METHODID_POST_TRENDING_METRICS_VIEW = 174;
  private static final int METHODID_LIST_TRENDING_METRICS_VIEWS = 175;
  private static final int METHODID_GET_MODULE = 176;
  private static final int METHODID_LIST_MODULES = 177;
  private static final int METHODID_POST_MODULES = 178;
  private static final int METHODID_PATCH_MODULES = 179;
  private static final int METHODID_DELETE_MODULES = 180;
  private static final int METHODID_GET_MODULE_VERSION = 181;
  private static final int METHODID_LIST_MODULE_VERSIONS = 182;
  private static final int METHODID_POST_MODULE_VERSIONS = 183;
  private static final int METHODID_PATCH_MODULE_VERSIONS = 184;
  private static final int METHODID_DELETE_MODULE_VERSIONS = 185;
  private static final int METHODID_GET_MODULE_VERSION_USAGE_COUNT = 186;
  private static final int METHODID_GET_INSTALLED_MODULE_VERSION = 187;
  private static final int METHODID_LIST_INSTALLED_MODULE_VERSIONS = 188;
  private static final int METHODID_POST_INSTALLED_MODULE_VERSIONS = 189;
  private static final int METHODID_DELETE_INSTALLED_MODULE_VERSIONS = 190;
  private static final int METHODID_POST_INSTALLED_MODULE_VERSIONS_KEY = 191;
  private static final int METHODID_POST_BULK_OPERATIONS = 192;
  private static final int METHODID_LIST_BULK_OPERATIONS = 193;
  private static final int METHODID_GET_BULK_OPERATION = 194;
  private static final int METHODID_CANCEL_BULK_OPERATIONS = 195;
  private static final int METHODID_DELETE_BULK_OPERATIONS = 196;
  private static final int METHODID_LIST_NEXT_TASK_ASSIGNMENTS = 197;
  private static final int METHODID_PUT_TASK_ASSIGNMENTS = 198;
  private static final int METHODID_LIST_INPUTS_ADD_JOBS = 199;
  private static final int METHODID_GET_INPUTS_ADD_JOB = 200;
  private static final int METHODID_CANCEL_INPUTS_ADD_JOB = 201;
  private static final int METHODID_POST_UPLOADS = 202;
  private static final int METHODID_PUT_UPLOAD_CONTENT_PARTS = 203;
  private static final int METHODID_GET_UPLOAD = 204;
  private static final int METHODID_LIST_UPLOADS = 205;
  private static final int METHODID_DELETE_UPLOADS = 206;
  private static final int METHODID_POST_INPUTS_DATA_SOURCES = 207;
  private static final int METHODID_GET_INPUTS_EXTRACTION_JOB = 208;
  private static final int METHODID_LIST_INPUTS_EXTRACTION_JOBS = 209;
  private static final int METHODID_CANCEL_INPUTS_EXTRACTION_JOBS = 210;
  private static final int METHODID_POST_INPUTS_UPLOADS = 211;
  private static final int METHODID_GET_RUNNER = 212;
  private static final int METHODID_LIST_RUNNERS = 213;
  private static final int METHODID_POST_RUNNERS = 214;
  private static final int METHODID_DELETE_RUNNERS = 215;
  private static final int METHODID_LIST_RUNNER_ITEMS = 216;
  private static final int METHODID_POST_RUNNER_ITEM_OUTPUTS = 217;
  private static final int METHODID_POST_MODEL_VERSIONS_TRAINING_TIME_ESTIMATE = 218;
  private static final int METHODID_STREAM_MODEL_OUTPUTS = 219;
  private static final int METHODID_POST_MODEL_VERSIONS_UPLOAD = 220;
  private static final int METHODID_PROCESS_RUNNER_ITEMS = 221;

  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_LIST_MODEL_CONCEPTS:
          serviceImpl.listModelConcepts((com.clarifai.grpc.api.ListModelConceptsRequest) 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_PATCH_ANNOTATIONS_SEARCHES:
          serviceImpl.patchAnnotationsSearches((com.clarifai.grpc.api.PatchAnnotationsSearchesRequest) 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_LIST_ANNOTATION_WORKERS:
          serviceImpl.listAnnotationWorkers((com.clarifai.grpc.api.ListAnnotationWorkersRequest) 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_GET_INPUT_VIDEO_MANIFEST:
          serviceImpl.getInputVideoManifest((com.clarifai.grpc.api.GetVideoManifestRequest) 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_PATCH_INPUTS_SEARCHES:
          serviceImpl.patchInputsSearches((com.clarifai.grpc.api.PatchInputsSearchesRequest) 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_GENERATE_MODEL_OUTPUTS:
          serviceImpl.generateModelOutputs((com.clarifai.grpc.api.PostModelOutputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_DATASETS:
          serviceImpl.listDatasets((com.clarifai.grpc.api.ListDatasetsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_DATASET:
          serviceImpl.getDataset((com.clarifai.grpc.api.GetDatasetRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_DATASETS:
          serviceImpl.postDatasets((com.clarifai.grpc.api.PostDatasetsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_DATASETS:
          serviceImpl.patchDatasets((com.clarifai.grpc.api.PatchDatasetsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_DATASETS:
          serviceImpl.deleteDatasets((com.clarifai.grpc.api.DeleteDatasetsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_DATASET_INPUTS:
          serviceImpl.listDatasetInputs((com.clarifai.grpc.api.ListDatasetInputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_DATASET_INPUT:
          serviceImpl.getDatasetInput((com.clarifai.grpc.api.GetDatasetInputRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_DATASET_INPUTS:
          serviceImpl.postDatasetInputs((com.clarifai.grpc.api.PostDatasetInputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_DATASET_INPUTS:
          serviceImpl.deleteDatasetInputs((com.clarifai.grpc.api.DeleteDatasetInputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_DATASET_VERSIONS:
          serviceImpl.listDatasetVersions((com.clarifai.grpc.api.ListDatasetVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_DATASET_VERSION:
          serviceImpl.getDatasetVersion((com.clarifai.grpc.api.GetDatasetVersionRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_DATASET_VERSION_METRICS_GROUPS:
          serviceImpl.listDatasetVersionMetricsGroups((com.clarifai.grpc.api.ListDatasetVersionMetricsGroupsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_DATASET_VERSIONS:
          serviceImpl.postDatasetVersions((com.clarifai.grpc.api.PostDatasetVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_DATASET_VERSIONS:
          serviceImpl.patchDatasetVersions((com.clarifai.grpc.api.PatchDatasetVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_DATASET_VERSIONS:
          serviceImpl.deleteDatasetVersions((com.clarifai.grpc.api.DeleteDatasetVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PUT_DATASET_VERSION_EXPORTS:
          serviceImpl.putDatasetVersionExports((com.clarifai.grpc.api.PutDatasetVersionExportsRequest) 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_GET_RESOURCE_COUNTS:
          serviceImpl.getResourceCounts((com.clarifai.grpc.api.GetResourceCountsRequest) 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_PATCH_MODEL_IDS:
          serviceImpl.patchModelIds((com.clarifai.grpc.api.PatchModelIdsRequest) 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_CHECK_CONSENTS:
          serviceImpl.patchModelCheckConsents((com.clarifai.grpc.api.PatchModelCheckConsentsRequest) 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_WORKFLOW_VERSIONS_UN_PUBLISH:
          serviceImpl.postWorkflowVersionsUnPublish((com.clarifai.grpc.api.PostWorkflowVersionsUnPublishRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_WORKFLOW_VERSIONS_PUBLISH:
          serviceImpl.postWorkflowVersionsPublish((com.clarifai.grpc.api.PostWorkflowVersionsPublishRequest) 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_PUT_MODEL_VERSION_EXPORTS:
          serviceImpl.putModelVersionExports((com.clarifai.grpc.api.PutModelVersionExportsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MODEL_VERSION_EXPORT:
          serviceImpl.getModelVersionExport((com.clarifai.grpc.api.GetModelVersionExportRequest) 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_POST_MODEL_VERSION_EVALUATIONS:
          serviceImpl.postModelVersionEvaluations((com.clarifai.grpc.api.PostModelVersionEvaluationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_MODEL_VERSION_EVALUATIONS:
          serviceImpl.listModelVersionEvaluations((com.clarifai.grpc.api.ListModelVersionEvaluationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MODEL_VERSION_EVALUATION:
          serviceImpl.getModelVersionEvaluation((com.clarifai.grpc.api.GetModelVersionEvaluationRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_EVALUATIONS:
          serviceImpl.postEvaluations((com.clarifai.grpc.api.PostEvaluationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_EVALUATIONS:
          serviceImpl.listEvaluations((com.clarifai.grpc.api.ListEvaluationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_EVALUATION:
          serviceImpl.getEvaluation((com.clarifai.grpc.api.GetEvaluationRequest) 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_PATCH_WORKFLOW_IDS:
          serviceImpl.patchWorkflowIds((com.clarifai.grpc.api.PatchWorkflowIdsRequest) 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_PATCH_APPS_IDS:
          serviceImpl.patchAppsIds((com.clarifai.grpc.api.PatchAppsIdsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_APP:
          serviceImpl.patchApp((com.clarifai.grpc.api.PatchAppRequest) 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_GET_USER:
          serviceImpl.getUser((com.clarifai.grpc.api.GetUserRequest) 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_PATCH_SEARCHES:
          serviceImpl.patchSearches((com.clarifai.grpc.api.PatchSearchesRequest) 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_ANNOTATION_FILTERS:
          serviceImpl.listAnnotationFilters((com.clarifai.grpc.api.ListAnnotationFiltersRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_ANNOTATION_FILTER:
          serviceImpl.getAnnotationFilter((com.clarifai.grpc.api.GetAnnotationFilterRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_ANNOTATION_FILTERS:
          serviceImpl.postAnnotationFilters((com.clarifai.grpc.api.PostAnnotationFiltersRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_ANNOTATION_FILTERS:
          serviceImpl.patchAnnotationFilters((com.clarifai.grpc.api.PatchAnnotationFiltersRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_ANNOTATION_FILTERS:
          serviceImpl.deleteAnnotationFilters((com.clarifai.grpc.api.DeleteAnnotationFiltersRequest) 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_LABEL_ORDERS:
          serviceImpl.postLabelOrders((com.clarifai.grpc.api.PostLabelOrdersRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_LABEL_ORDER:
          serviceImpl.getLabelOrder((com.clarifai.grpc.api.GetLabelOrderRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_LABEL_ORDERS:
          serviceImpl.listLabelOrders((com.clarifai.grpc.api.ListLabelOrdersRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_LABEL_ORDERS:
          serviceImpl.patchLabelOrders((com.clarifai.grpc.api.PatchLabelOrdersRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_LABEL_ORDERS:
          serviceImpl.deleteLabelOrders((com.clarifai.grpc.api.DeleteLabelOrdersRequest) 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;
        case METHODID_GET_MODULE:
          serviceImpl.getModule((com.clarifai.grpc.api.GetModuleRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_MODULES:
          serviceImpl.listModules((com.clarifai.grpc.api.ListModulesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_MODULES:
          serviceImpl.postModules((com.clarifai.grpc.api.PostModulesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_MODULES:
          serviceImpl.patchModules((com.clarifai.grpc.api.PatchModulesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_MODULES:
          serviceImpl.deleteModules((com.clarifai.grpc.api.DeleteModulesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MODULE_VERSION:
          serviceImpl.getModuleVersion((com.clarifai.grpc.api.GetModuleVersionRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_MODULE_VERSIONS:
          serviceImpl.listModuleVersions((com.clarifai.grpc.api.ListModuleVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_MODULE_VERSIONS:
          serviceImpl.postModuleVersions((com.clarifai.grpc.api.PostModuleVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PATCH_MODULE_VERSIONS:
          serviceImpl.patchModuleVersions((com.clarifai.grpc.api.PatchModuleVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_MODULE_VERSIONS:
          serviceImpl.deleteModuleVersions((com.clarifai.grpc.api.DeleteModuleVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_MODULE_VERSION_USAGE_COUNT:
          serviceImpl.getModuleVersionUsageCount((com.clarifai.grpc.api.GetModuleVersionUsageCountRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_INSTALLED_MODULE_VERSION:
          serviceImpl.getInstalledModuleVersion((com.clarifai.grpc.api.GetInstalledModuleVersionRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_INSTALLED_MODULE_VERSIONS:
          serviceImpl.listInstalledModuleVersions((com.clarifai.grpc.api.ListInstalledModuleVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_INSTALLED_MODULE_VERSIONS:
          serviceImpl.postInstalledModuleVersions((com.clarifai.grpc.api.PostInstalledModuleVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_INSTALLED_MODULE_VERSIONS:
          serviceImpl.deleteInstalledModuleVersions((com.clarifai.grpc.api.DeleteInstalledModuleVersionsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_INSTALLED_MODULE_VERSIONS_KEY:
          serviceImpl.postInstalledModuleVersionsKey((com.clarifai.grpc.api.PostInstalledModuleVersionsKeyRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_BULK_OPERATIONS:
          serviceImpl.postBulkOperations((com.clarifai.grpc.api.PostBulkOperationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_BULK_OPERATIONS:
          serviceImpl.listBulkOperations((com.clarifai.grpc.api.ListBulkOperationsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_BULK_OPERATION:
          serviceImpl.getBulkOperation((com.clarifai.grpc.api.GetBulkOperationRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_CANCEL_BULK_OPERATIONS:
          serviceImpl.cancelBulkOperations((com.clarifai.grpc.api.CancelBulkOperationRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_BULK_OPERATIONS:
          serviceImpl.deleteBulkOperations((com.clarifai.grpc.api.DeleteBulkOperationRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_NEXT_TASK_ASSIGNMENTS:
          serviceImpl.listNextTaskAssignments((com.clarifai.grpc.api.ListNextTaskAssignmentsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PUT_TASK_ASSIGNMENTS:
          serviceImpl.putTaskAssignments((com.clarifai.grpc.api.PutTaskAssignmentsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_INPUTS_ADD_JOBS:
          serviceImpl.listInputsAddJobs((com.clarifai.grpc.api.ListInputsAddJobsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_INPUTS_ADD_JOB:
          serviceImpl.getInputsAddJob((com.clarifai.grpc.api.GetInputsAddJobRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_CANCEL_INPUTS_ADD_JOB:
          serviceImpl.cancelInputsAddJob((com.clarifai.grpc.api.CancelInputsAddJobRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_UPLOADS:
          serviceImpl.postUploads((com.clarifai.grpc.api.PostUploadsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_PUT_UPLOAD_CONTENT_PARTS:
          serviceImpl.putUploadContentParts((com.clarifai.grpc.api.PutUploadContentPartsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_UPLOAD:
          serviceImpl.getUpload((com.clarifai.grpc.api.GetUploadRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_UPLOADS:
          serviceImpl.listUploads((com.clarifai.grpc.api.ListUploadsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_UPLOADS:
          serviceImpl.deleteUploads((com.clarifai.grpc.api.DeleteUploadsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_INPUTS_DATA_SOURCES:
          serviceImpl.postInputsDataSources((com.clarifai.grpc.api.PostInputsDataSourcesRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_INPUTS_EXTRACTION_JOB:
          serviceImpl.getInputsExtractionJob((com.clarifai.grpc.api.GetInputsExtractionJobRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_INPUTS_EXTRACTION_JOBS:
          serviceImpl.listInputsExtractionJobs((com.clarifai.grpc.api.ListInputsExtractionJobsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_CANCEL_INPUTS_EXTRACTION_JOBS:
          serviceImpl.cancelInputsExtractionJobs((com.clarifai.grpc.api.CancelInputsExtractionJobsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_INPUTS_UPLOADS:
          serviceImpl.postInputsUploads((com.clarifai.grpc.api.PostInputsUploadsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_RUNNER:
          serviceImpl.getRunner((com.clarifai.grpc.api.GetRunnerRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_RUNNERS:
          serviceImpl.listRunners((com.clarifai.grpc.api.ListRunnersRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_RUNNERS:
          serviceImpl.postRunners((com.clarifai.grpc.api.PostRunnersRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_RUNNERS:
          serviceImpl.deleteRunners((com.clarifai.grpc.api.DeleteRunnersRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_LIST_RUNNER_ITEMS:
          serviceImpl.listRunnerItems((com.clarifai.grpc.api.ListRunnerItemsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_RUNNER_ITEM_OUTPUTS:
          serviceImpl.postRunnerItemOutputs((com.clarifai.grpc.api.PostRunnerItemOutputsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_POST_MODEL_VERSIONS_TRAINING_TIME_ESTIMATE:
          serviceImpl.postModelVersionsTrainingTimeEstimate((com.clarifai.grpc.api.PostModelVersionsTrainingTimeEstimateRequest) 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) {
        case METHODID_STREAM_MODEL_OUTPUTS:
          return (io.grpc.stub.StreamObserver) serviceImpl.streamModelOutputs(
              (io.grpc.stub.StreamObserver) responseObserver);
        case METHODID_POST_MODEL_VERSIONS_UPLOAD:
          return (io.grpc.stub.StreamObserver) serviceImpl.postModelVersionsUpload(
              (io.grpc.stub.StreamObserver) responseObserver);
        case METHODID_PROCESS_RUNNER_ITEMS:
          return (io.grpc.stub.StreamObserver) serviceImpl.processRunnerItems(
              (io.grpc.stub.StreamObserver) responseObserver);
        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(getListModelConceptsMethod())
              .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(getPatchAnnotationsSearchesMethod())
              .addMethod(getPostAnnotationsSearchesMethod())
              .addMethod(getListAnnotationWorkersMethod())
              .addMethod(getGetInputCountMethod())
              .addMethod(getStreamInputsMethod())
              .addMethod(getGetInputSamplesMethod())
              .addMethod(getGetInputMethod())
              .addMethod(getGetInputVideoManifestMethod())
              .addMethod(getListInputsMethod())
              .addMethod(getPostInputsMethod())
              .addMethod(getPatchInputsMethod())
              .addMethod(getDeleteInputMethod())
              .addMethod(getDeleteInputsMethod())
              .addMethod(getPatchInputsSearchesMethod())
              .addMethod(getPostInputsSearchesMethod())
              .addMethod(getPostModelOutputsMethod())
              .addMethod(getGenerateModelOutputsMethod())
              .addMethod(getStreamModelOutputsMethod())
              .addMethod(getListDatasetsMethod())
              .addMethod(getGetDatasetMethod())
              .addMethod(getPostDatasetsMethod())
              .addMethod(getPatchDatasetsMethod())
              .addMethod(getDeleteDatasetsMethod())
              .addMethod(getListDatasetInputsMethod())
              .addMethod(getGetDatasetInputMethod())
              .addMethod(getPostDatasetInputsMethod())
              .addMethod(getDeleteDatasetInputsMethod())
              .addMethod(getListDatasetVersionsMethod())
              .addMethod(getGetDatasetVersionMethod())
              .addMethod(getListDatasetVersionMetricsGroupsMethod())
              .addMethod(getPostDatasetVersionsMethod())
              .addMethod(getPatchDatasetVersionsMethod())
              .addMethod(getDeleteDatasetVersionsMethod())
              .addMethod(getPutDatasetVersionExportsMethod())
              .addMethod(getGetModelTypeMethod())
              .addMethod(getListOpenSourceLicensesMethod())
              .addMethod(getListModelTypesMethod())
              .addMethod(getGetModelMethod())
              .addMethod(getGetModelOutputInfoMethod())
              .addMethod(getListModelsMethod())
              .addMethod(getGetResourceCountsMethod())
              .addMethod(getPostModelsSearchesMethod())
              .addMethod(getPostModelsMethod())
              .addMethod(getPatchModelsMethod())
              .addMethod(getPatchModelIdsMethod())
              .addMethod(getDeleteModelMethod())
              .addMethod(getDeleteModelsMethod())
              .addMethod(getPatchModelCheckConsentsMethod())
              .addMethod(getPatchModelToolkitsMethod())
              .addMethod(getPatchModelUseCasesMethod())
              .addMethod(getPatchModelLanguagesMethod())
              .addMethod(getListModelInputsMethod())
              .addMethod(getGetModelVersionMethod())
              .addMethod(getListModelVersionsMethod())
              .addMethod(getPostWorkflowVersionsUnPublishMethod())
              .addMethod(getPostWorkflowVersionsPublishMethod())
              .addMethod(getPostModelVersionsPublishMethod())
              .addMethod(getPostModelVersionsUnPublishMethod())
              .addMethod(getPostModelVersionsMethod())
              .addMethod(getPatchModelVersionsMethod())
              .addMethod(getDeleteModelVersionMethod())
              .addMethod(getPostModelVersionsUploadMethod())
              .addMethod(getPutModelVersionExportsMethod())
              .addMethod(getGetModelVersionExportMethod())
              .addMethod(getGetModelVersionMetricsMethod())
              .addMethod(getPostModelVersionMetricsMethod())
              .addMethod(getPostModelVersionEvaluationsMethod())
              .addMethod(getListModelVersionEvaluationsMethod())
              .addMethod(getGetModelVersionEvaluationMethod())
              .addMethod(getPostEvaluationsMethod())
              .addMethod(getListEvaluationsMethod())
              .addMethod(getGetEvaluationMethod())
              .addMethod(getListModelReferencesMethod())
              .addMethod(getGetModelVersionInputExampleMethod())
              .addMethod(getListModelVersionInputExamplesMethod())
              .addMethod(getGetWorkflowMethod())
              .addMethod(getListWorkflowsMethod())
              .addMethod(getPostWorkflowsMethod())
              .addMethod(getPatchWorkflowsMethod())
              .addMethod(getPatchWorkflowIdsMethod())
              .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(getPatchAppsIdsMethod())
              .addMethod(getPatchAppMethod())
              .addMethod(getPostAppsSearchesMethod())
              .addMethod(getGetUserMethod())
              .addMethod(getPostValidatePasswordMethod())
              .addMethod(getGetSearchMethod())
              .addMethod(getListSearchesMethod())
              .addMethod(getPatchSearchesMethod())
              .addMethod(getPostSearchesMethod())
              .addMethod(getPostSearchesByIDMethod())
              .addMethod(getPostAnnotationSearchMetricsMethod())
              .addMethod(getGetAnnotationSearchMetricsMethod())
              .addMethod(getListAnnotationSearchMetricsMethod())
              .addMethod(getDeleteAnnotationSearchMetricsMethod())
              .addMethod(getDeleteSearchMethod())
              .addMethod(getListAnnotationFiltersMethod())
              .addMethod(getGetAnnotationFilterMethod())
              .addMethod(getPostAnnotationFiltersMethod())
              .addMethod(getPatchAnnotationFiltersMethod())
              .addMethod(getDeleteAnnotationFiltersMethod())
              .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(getPostLabelOrdersMethod())
              .addMethod(getGetLabelOrderMethod())
              .addMethod(getListLabelOrdersMethod())
              .addMethod(getPatchLabelOrdersMethod())
              .addMethod(getDeleteLabelOrdersMethod())
              .addMethod(getPostCollectorsMethod())
              .addMethod(getGetCollectorMethod())
              .addMethod(getListCollectorsMethod())
              .addMethod(getPatchCollectorsMethod())
              .addMethod(getDeleteCollectorsMethod())
              .addMethod(getPostStatValuesMethod())
              .addMethod(getPostStatValuesAggregateMethod())
              .addMethod(getPostTrendingMetricsViewMethod())
              .addMethod(getListTrendingMetricsViewsMethod())
              .addMethod(getGetModuleMethod())
              .addMethod(getListModulesMethod())
              .addMethod(getPostModulesMethod())
              .addMethod(getPatchModulesMethod())
              .addMethod(getDeleteModulesMethod())
              .addMethod(getGetModuleVersionMethod())
              .addMethod(getListModuleVersionsMethod())
              .addMethod(getPostModuleVersionsMethod())
              .addMethod(getPatchModuleVersionsMethod())
              .addMethod(getDeleteModuleVersionsMethod())
              .addMethod(getGetModuleVersionUsageCountMethod())
              .addMethod(getGetInstalledModuleVersionMethod())
              .addMethod(getListInstalledModuleVersionsMethod())
              .addMethod(getPostInstalledModuleVersionsMethod())
              .addMethod(getDeleteInstalledModuleVersionsMethod())
              .addMethod(getPostInstalledModuleVersionsKeyMethod())
              .addMethod(getPostBulkOperationsMethod())
              .addMethod(getListBulkOperationsMethod())
              .addMethod(getGetBulkOperationMethod())
              .addMethod(getCancelBulkOperationsMethod())
              .addMethod(getDeleteBulkOperationsMethod())
              .addMethod(getListNextTaskAssignmentsMethod())
              .addMethod(getPutTaskAssignmentsMethod())
              .addMethod(getListInputsAddJobsMethod())
              .addMethod(getGetInputsAddJobMethod())
              .addMethod(getCancelInputsAddJobMethod())
              .addMethod(getPostUploadsMethod())
              .addMethod(getPutUploadContentPartsMethod())
              .addMethod(getGetUploadMethod())
              .addMethod(getListUploadsMethod())
              .addMethod(getDeleteUploadsMethod())
              .addMethod(getPostInputsDataSourcesMethod())
              .addMethod(getGetInputsExtractionJobMethod())
              .addMethod(getListInputsExtractionJobsMethod())
              .addMethod(getCancelInputsExtractionJobsMethod())
              .addMethod(getPostInputsUploadsMethod())
              .addMethod(getGetRunnerMethod())
              .addMethod(getListRunnersMethod())
              .addMethod(getPostRunnersMethod())
              .addMethod(getDeleteRunnersMethod())
              .addMethod(getListRunnerItemsMethod())
              .addMethod(getPostRunnerItemOutputsMethod())
              .addMethod(getProcessRunnerItemsMethod())
              .addMethod(getPostModelVersionsTrainingTimeEstimateMethod())
              .build();
        }
      }
    }
    return result;
  }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy