• Home
• software.momento.java
• client-protos
• 0.101.0
• source code
• VectorIndexGrpc.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

vectorindex.VectorIndexGrpc Maven / Gradle / Ivy

package vectorindex;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.53.0)",
    comments = "Source: vectorindex.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class VectorIndexGrpc {

  private VectorIndexGrpc() {}

  public static final String SERVICE_NAME = "vectorindex.VectorIndex";

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

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "UpsertItemBatch",
      requestType = vectorindex.Vectorindex._UpsertItemBatchRequest.class,
      responseType = vectorindex.Vectorindex._UpsertItemBatchResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getUpsertItemBatchMethod() {
    io.grpc.MethodDescriptor getUpsertItemBatchMethod;
    if ((getUpsertItemBatchMethod = VectorIndexGrpc.getUpsertItemBatchMethod) == null) {
      synchronized (VectorIndexGrpc.class) {
        if ((getUpsertItemBatchMethod = VectorIndexGrpc.getUpsertItemBatchMethod) == null) {
          VectorIndexGrpc.getUpsertItemBatchMethod = getUpsertItemBatchMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpsertItemBatch"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._UpsertItemBatchRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._UpsertItemBatchResponse.getDefaultInstance()))
              .setSchemaDescriptor(new VectorIndexMethodDescriptorSupplier("UpsertItemBatch"))
              .build();
        }
      }
    }
    return getUpsertItemBatchMethod;
  }

  private static volatile io.grpc.MethodDescriptor getDeleteItemBatchMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteItemBatch",
      requestType = vectorindex.Vectorindex._DeleteItemBatchRequest.class,
      responseType = vectorindex.Vectorindex._DeleteItemBatchResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getDeleteItemBatchMethod() {
    io.grpc.MethodDescriptor getDeleteItemBatchMethod;
    if ((getDeleteItemBatchMethod = VectorIndexGrpc.getDeleteItemBatchMethod) == null) {
      synchronized (VectorIndexGrpc.class) {
        if ((getDeleteItemBatchMethod = VectorIndexGrpc.getDeleteItemBatchMethod) == null) {
          VectorIndexGrpc.getDeleteItemBatchMethod = getDeleteItemBatchMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteItemBatch"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._DeleteItemBatchRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._DeleteItemBatchResponse.getDefaultInstance()))
              .setSchemaDescriptor(new VectorIndexMethodDescriptorSupplier("DeleteItemBatch"))
              .build();
        }
      }
    }
    return getDeleteItemBatchMethod;
  }

  private static volatile io.grpc.MethodDescriptor getSearchMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Search",
      requestType = vectorindex.Vectorindex._SearchRequest.class,
      responseType = vectorindex.Vectorindex._SearchResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getSearchMethod() {
    io.grpc.MethodDescriptor getSearchMethod;
    if ((getSearchMethod = VectorIndexGrpc.getSearchMethod) == null) {
      synchronized (VectorIndexGrpc.class) {
        if ((getSearchMethod = VectorIndexGrpc.getSearchMethod) == null) {
          VectorIndexGrpc.getSearchMethod = getSearchMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Search"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._SearchRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._SearchResponse.getDefaultInstance()))
              .setSchemaDescriptor(new VectorIndexMethodDescriptorSupplier("Search"))
              .build();
        }
      }
    }
    return getSearchMethod;
  }

  private static volatile io.grpc.MethodDescriptor getSearchAndFetchVectorsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SearchAndFetchVectors",
      requestType = vectorindex.Vectorindex._SearchAndFetchVectorsRequest.class,
      responseType = vectorindex.Vectorindex._SearchAndFetchVectorsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getSearchAndFetchVectorsMethod() {
    io.grpc.MethodDescriptor getSearchAndFetchVectorsMethod;
    if ((getSearchAndFetchVectorsMethod = VectorIndexGrpc.getSearchAndFetchVectorsMethod) == null) {
      synchronized (VectorIndexGrpc.class) {
        if ((getSearchAndFetchVectorsMethod = VectorIndexGrpc.getSearchAndFetchVectorsMethod) == null) {
          VectorIndexGrpc.getSearchAndFetchVectorsMethod = getSearchAndFetchVectorsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SearchAndFetchVectors"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._SearchAndFetchVectorsRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._SearchAndFetchVectorsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new VectorIndexMethodDescriptorSupplier("SearchAndFetchVectors"))
              .build();
        }
      }
    }
    return getSearchAndFetchVectorsMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetItemMetadataBatchMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetItemMetadataBatch",
      requestType = vectorindex.Vectorindex._GetItemMetadataBatchRequest.class,
      responseType = vectorindex.Vectorindex._GetItemMetadataBatchResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetItemMetadataBatchMethod() {
    io.grpc.MethodDescriptor getGetItemMetadataBatchMethod;
    if ((getGetItemMetadataBatchMethod = VectorIndexGrpc.getGetItemMetadataBatchMethod) == null) {
      synchronized (VectorIndexGrpc.class) {
        if ((getGetItemMetadataBatchMethod = VectorIndexGrpc.getGetItemMetadataBatchMethod) == null) {
          VectorIndexGrpc.getGetItemMetadataBatchMethod = getGetItemMetadataBatchMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetItemMetadataBatch"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._GetItemMetadataBatchRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._GetItemMetadataBatchResponse.getDefaultInstance()))
              .setSchemaDescriptor(new VectorIndexMethodDescriptorSupplier("GetItemMetadataBatch"))
              .build();
        }
      }
    }
    return getGetItemMetadataBatchMethod;
  }

  private static volatile io.grpc.MethodDescriptor getGetItemBatchMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetItemBatch",
      requestType = vectorindex.Vectorindex._GetItemBatchRequest.class,
      responseType = vectorindex.Vectorindex._GetItemBatchResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getGetItemBatchMethod() {
    io.grpc.MethodDescriptor getGetItemBatchMethod;
    if ((getGetItemBatchMethod = VectorIndexGrpc.getGetItemBatchMethod) == null) {
      synchronized (VectorIndexGrpc.class) {
        if ((getGetItemBatchMethod = VectorIndexGrpc.getGetItemBatchMethod) == null) {
          VectorIndexGrpc.getGetItemBatchMethod = getGetItemBatchMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetItemBatch"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._GetItemBatchRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._GetItemBatchResponse.getDefaultInstance()))
              .setSchemaDescriptor(new VectorIndexMethodDescriptorSupplier("GetItemBatch"))
              .build();
        }
      }
    }
    return getGetItemBatchMethod;
  }

  private static volatile io.grpc.MethodDescriptor getCountItemsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "CountItems",
      requestType = vectorindex.Vectorindex._CountItemsRequest.class,
      responseType = vectorindex.Vectorindex._CountItemsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getCountItemsMethod() {
    io.grpc.MethodDescriptor getCountItemsMethod;
    if ((getCountItemsMethod = VectorIndexGrpc.getCountItemsMethod) == null) {
      synchronized (VectorIndexGrpc.class) {
        if ((getCountItemsMethod = VectorIndexGrpc.getCountItemsMethod) == null) {
          VectorIndexGrpc.getCountItemsMethod = getCountItemsMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CountItems"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._CountItemsRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  vectorindex.Vectorindex._CountItemsResponse.getDefaultInstance()))
              .setSchemaDescriptor(new VectorIndexMethodDescriptorSupplier("CountItems"))
              .build();
        }
      }
    }
    return getCountItemsMethod;
  }

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

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

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

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

    /**
     */
    public void upsertItemBatch(vectorindex.Vectorindex._UpsertItemBatchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpsertItemBatchMethod(), responseObserver);
    }

    /**
     */
    public void deleteItemBatch(vectorindex.Vectorindex._DeleteItemBatchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteItemBatchMethod(), responseObserver);
    }

    /**
     */
    public void search(vectorindex.Vectorindex._SearchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSearchMethod(), responseObserver);
    }

    /**
     */
    public void searchAndFetchVectors(vectorindex.Vectorindex._SearchAndFetchVectorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSearchAndFetchVectorsMethod(), responseObserver);
    }

    /**
     */
    public void getItemMetadataBatch(vectorindex.Vectorindex._GetItemMetadataBatchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetItemMetadataBatchMethod(), responseObserver);
    }

    /**
     */
    public void getItemBatch(vectorindex.Vectorindex._GetItemBatchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetItemBatchMethod(), responseObserver);
    }

    /**
     */
    public void countItems(vectorindex.Vectorindex._CountItemsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCountItemsMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getUpsertItemBatchMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                vectorindex.Vectorindex._UpsertItemBatchRequest,
                vectorindex.Vectorindex._UpsertItemBatchResponse>(
                  this, METHODID_UPSERT_ITEM_BATCH)))
          .addMethod(
            getDeleteItemBatchMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                vectorindex.Vectorindex._DeleteItemBatchRequest,
                vectorindex.Vectorindex._DeleteItemBatchResponse>(
                  this, METHODID_DELETE_ITEM_BATCH)))
          .addMethod(
            getSearchMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                vectorindex.Vectorindex._SearchRequest,
                vectorindex.Vectorindex._SearchResponse>(
                  this, METHODID_SEARCH)))
          .addMethod(
            getSearchAndFetchVectorsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                vectorindex.Vectorindex._SearchAndFetchVectorsRequest,
                vectorindex.Vectorindex._SearchAndFetchVectorsResponse>(
                  this, METHODID_SEARCH_AND_FETCH_VECTORS)))
          .addMethod(
            getGetItemMetadataBatchMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                vectorindex.Vectorindex._GetItemMetadataBatchRequest,
                vectorindex.Vectorindex._GetItemMetadataBatchResponse>(
                  this, METHODID_GET_ITEM_METADATA_BATCH)))
          .addMethod(
            getGetItemBatchMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                vectorindex.Vectorindex._GetItemBatchRequest,
                vectorindex.Vectorindex._GetItemBatchResponse>(
                  this, METHODID_GET_ITEM_BATCH)))
          .addMethod(
            getCountItemsMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                vectorindex.Vectorindex._CountItemsRequest,
                vectorindex.Vectorindex._CountItemsResponse>(
                  this, METHODID_COUNT_ITEMS)))
          .build();
    }
  }

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

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

    /**
     */
    public void upsertItemBatch(vectorindex.Vectorindex._UpsertItemBatchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUpsertItemBatchMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void deleteItemBatch(vectorindex.Vectorindex._DeleteItemBatchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteItemBatchMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void search(vectorindex.Vectorindex._SearchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSearchMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void searchAndFetchVectors(vectorindex.Vectorindex._SearchAndFetchVectorsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSearchAndFetchVectorsMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getItemMetadataBatch(vectorindex.Vectorindex._GetItemMetadataBatchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetItemMetadataBatchMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getItemBatch(vectorindex.Vectorindex._GetItemBatchRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetItemBatchMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void countItems(vectorindex.Vectorindex._CountItemsRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCountItemsMethod(), getCallOptions()), request, responseObserver);
    }
  }

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

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

    /**
     */
    public vectorindex.Vectorindex._UpsertItemBatchResponse upsertItemBatch(vectorindex.Vectorindex._UpsertItemBatchRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUpsertItemBatchMethod(), getCallOptions(), request);
    }

    /**
     */
    public vectorindex.Vectorindex._DeleteItemBatchResponse deleteItemBatch(vectorindex.Vectorindex._DeleteItemBatchRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteItemBatchMethod(), getCallOptions(), request);
    }

    /**
     */
    public vectorindex.Vectorindex._SearchResponse search(vectorindex.Vectorindex._SearchRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSearchMethod(), getCallOptions(), request);
    }

    /**
     */
    public vectorindex.Vectorindex._SearchAndFetchVectorsResponse searchAndFetchVectors(vectorindex.Vectorindex._SearchAndFetchVectorsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSearchAndFetchVectorsMethod(), getCallOptions(), request);
    }

    /**
     */
    public vectorindex.Vectorindex._GetItemMetadataBatchResponse getItemMetadataBatch(vectorindex.Vectorindex._GetItemMetadataBatchRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetItemMetadataBatchMethod(), getCallOptions(), request);
    }

    /**
     */
    public vectorindex.Vectorindex._GetItemBatchResponse getItemBatch(vectorindex.Vectorindex._GetItemBatchRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetItemBatchMethod(), getCallOptions(), request);
    }

    /**
     */
    public vectorindex.Vectorindex._CountItemsResponse countItems(vectorindex.Vectorindex._CountItemsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCountItemsMethod(), getCallOptions(), request);
    }
  }

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

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

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture upsertItemBatch(
        vectorindex.Vectorindex._UpsertItemBatchRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUpsertItemBatchMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture deleteItemBatch(
        vectorindex.Vectorindex._DeleteItemBatchRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteItemBatchMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture search(
        vectorindex.Vectorindex._SearchRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSearchMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture searchAndFetchVectors(
        vectorindex.Vectorindex._SearchAndFetchVectorsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSearchAndFetchVectorsMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture getItemMetadataBatch(
        vectorindex.Vectorindex._GetItemMetadataBatchRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetItemMetadataBatchMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture getItemBatch(
        vectorindex.Vectorindex._GetItemBatchRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetItemBatchMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture countItems(
        vectorindex.Vectorindex._CountItemsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCountItemsMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_UPSERT_ITEM_BATCH = 0;
  private static final int METHODID_DELETE_ITEM_BATCH = 1;
  private static final int METHODID_SEARCH = 2;
  private static final int METHODID_SEARCH_AND_FETCH_VECTORS = 3;
  private static final int METHODID_GET_ITEM_METADATA_BATCH = 4;
  private static final int METHODID_GET_ITEM_BATCH = 5;
  private static final int METHODID_COUNT_ITEMS = 6;

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

    MethodHandlers(VectorIndexImplBase 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_UPSERT_ITEM_BATCH:
          serviceImpl.upsertItemBatch((vectorindex.Vectorindex._UpsertItemBatchRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_DELETE_ITEM_BATCH:
          serviceImpl.deleteItemBatch((vectorindex.Vectorindex._DeleteItemBatchRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_SEARCH:
          serviceImpl.search((vectorindex.Vectorindex._SearchRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_SEARCH_AND_FETCH_VECTORS:
          serviceImpl.searchAndFetchVectors((vectorindex.Vectorindex._SearchAndFetchVectorsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_ITEM_METADATA_BATCH:
          serviceImpl.getItemMetadataBatch((vectorindex.Vectorindex._GetItemMetadataBatchRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_GET_ITEM_BATCH:
          serviceImpl.getItemBatch((vectorindex.Vectorindex._GetItemBatchRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_COUNT_ITEMS:
          serviceImpl.countItems((vectorindex.Vectorindex._CountItemsRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

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

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

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

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

  private static final class VectorIndexFileDescriptorSupplier
      extends VectorIndexBaseDescriptorSupplier {
    VectorIndexFileDescriptorSupplier() {}
  }

  private static final class VectorIndexMethodDescriptorSupplier
      extends VectorIndexBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    VectorIndexMethodDescriptorSupplier(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 (VectorIndexGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new VectorIndexFileDescriptorSupplier())
              .addMethod(getUpsertItemBatchMethod())
              .addMethod(getDeleteItemBatchMethod())
              .addMethod(getSearchMethod())
              .addMethod(getSearchAndFetchVectorsMethod())
              .addMethod(getGetItemMetadataBatchMethod())
              .addMethod(getGetItemBatchMethod())
              .addMethod(getCountItemsMethod())
              .build();
        }
      }
    }
    return result;
  }
}